Assert
Стиль assert очень похож на встроенный модуль assert node.js, с небольшими дополнительными возможностями. Из трёх стилей, assert — единственный, который нельзя использовать цепочкой. Обратитесь к Руководству по стилям для сравнения.
Справочник по API
assert(expression, message)
Напишите собственные выражения для проверки.
assert('foo' !== 'bar', 'foo is not bar');
assert(Array.isArray([]), 'empty arrays are arrays');
.fail([message])
.fail(actual, expected, [message], [operator])
Выбросить ошибку. Совместимо с модулем assert node.js.
assert.fail();
assert.fail("custom error message");
assert.fail(1, 2);
assert.fail(1, 2, "custom error message");
assert.fail(1, 2, "custom error message", ">");
assert.fail(1, 2, undefined, ">");
.isOk(object, [message])
Проверяет, что object имеет истинное значение.
assert.isOk('everything', 'everything is ok');
assert.isOk(false, 'this will fail');
.isNotOk(object, [message])
Проверяет, что object имеет ложное значение.
assert.isNotOk('everything', 'this will fail');
assert.isNotOk(false, 'this will pass');
.equal(actual, expected, [message])
Проверяет нестрогое равенство (==) actual и expected.
assert.equal(3, '3', '== coerces values to strings');
.notEqual(actual, expected, [message])
Проверяет нестрогое неравенство (!=) actual и expected.
assert.notEqual(3, 4, 'these numbers are not equal');
.strictEqual(actual, expected, [message])
Проверяет строгое равенство (===) actual и expected.
assert.strictEqual(true, true, 'these booleans are strictly equal');
.notStrictEqual(actual, expected, [message])
Проверяет строгое неравенство (!==) actual и expected.
assert.notStrictEqual(3, '3', 'no coercion for strict equality');
.deepEqual(actual, expected, [message])
Проверяет, что actual глубоко равно expected.
assert.deepEqual({ tea: 'green' }, { tea: 'green' });
.notDeepEqual(actual, expected, [message])
Проверяет, что actual не глубоко равно expected.
assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });
.isAbove(valueToCheck, valueToBeAbove, [message])
Проверяет, что valueToCheck строго больше (>) чем valueToBeAbove.
assert.isAbove(5, 2, '5 is strictly greater than 2');
.isAtLeast(valueToCheck, valueToBeAtLeast, [message])
Проверяет, что valueToCheck больше или равно (>=) valueToBeAtLeast.
assert.isAtLeast(5, 2, '5 is greater or equal to 2');
assert.isAtLeast(3, 3, '3 is greater or equal to 3');
.isBelow(valueToCheck, valueToBeBelow, [message])
Проверяет, что valueToCheck строго меньше (<) чем valueToBeBelow.
assert.isBelow(3, 6, '3 is strictly less than 6');
.isAtMost(valueToCheck, valueToBeAtMost, [message])
Проверяет, что valueToCheck меньше или равно (<=) valueToBeAtMost.
assert.isAtMost(3, 6, '3 is less than or equal to 6');
assert.isAtMost(4, 4, '4 is less than or equal to 4');
.isTrue(value, [message])
Проверяет, что value равно true.
var teaServed = true;
assert.isTrue(teaServed, 'the tea has been served');
.isNotTrue(value, [message])
Проверяет, что value не равно true.
var tea = 'tasty chai';
assert.isNotTrue(tea, 'great, time for tea!');
.isFalse(value, [message])
Утверждает, что value является ложным.
var teaServed = false;
assert.isFalse(teaServed, 'no tea yet? hmm...');
.isNotFalse(value, [message])
Утверждает, что value не является ложным.
var tea = 'tasty chai';
assert.isNotFalse(tea, 'great, time for tea!');
.isNull(value, [message])
Утверждает, что value равно null.
assert.isNull(err, 'there was no error');
.isNotNull(value, [message])
Утверждает, что value не равно null.
var tea = 'tasty chai';
assert.isNotNull(tea, 'great, time for tea!');
.isNaN
Утверждает, что значение является NaN.
assert.isNaN(NaN, 'NaN is NaN');
.isNotNaN
Утверждает, что значение не является NaN.
assert.isNotNaN(4, '4 is not NaN');
.exists
Утверждает, что целевой объект не является ни null, ни undefined.
var foo = 'hi';
assert.exists(foo, 'foo is neither `null` nor `undefined`');
.notExists
Утверждает, что целевой объект является либо null, либо undefined.
var bar = null
, baz;
assert.notExists(bar);
assert.notExists(baz, 'baz is either null or undefined');
.isUndefined(value, [message])
Утверждает, что value является undefined.
var tea;
assert.isUndefined(tea, 'no tea defined');
.isDefined(value, [message])
Утверждает, что value не является undefined.
var tea = 'cup of chai';
assert.isDefined(tea, 'tea has been defined');
.isFunction(value, [message])
Утверждает, что value является функцией.
function serveTea() { return 'cup of tea'; };
assert.isFunction(serveTea, 'great, we can have tea now');
.isNotFunction(value, [message])
Утверждает, что value не является функцией.
var serveTea = [ 'heat', 'pour', 'sip' ];
assert.isNotFunction(serveTea, 'great, we have listed the steps');
.isObject(value, [message])
Утверждает, что value является объектом типа «Объект» (как показано Object.prototype.toString). Утверждение не соответствует подклассам объектов.
var selection = { name: 'Chai', serve: 'with spices' };
assert.isObject(selection, 'tea selection is an object');
.isNotObject(value, [message])
Утверждает, что value не является объектом типа «Объект» (как показано Object.prototype.toString).
var selection = 'chai'
assert.isNotObject(selection, 'tea selection is not an object');
assert.isNotObject(null, 'null is not an object');
.isArray(value, [message])
Утверждает, что value является массивом.
var menu = [ 'green', 'chai', 'oolong' ];
assert.isArray(menu, 'what kind of tea do we want?');
.isNotArray(value, [message])
Утверждает, что value не является массивом.
var menu = 'green|chai|oolong';
assert.isNotArray(menu, 'what kind of tea do we want?');
.isString(value, [message])
Утверждает, что value является строкой.
var teaOrder = 'chai';
assert.isString(teaOrder, 'order placed');
.isNotString(value, [message])
Утверждает, что value не является строкой.
var teaOrder = 4;
assert.isNotString(teaOrder, 'order placed');
.isNumber(value, [message])
Утверждает, что value является числом.
var cups = 2;
assert.isNumber(cups, 'how many cups');
.isNotNumber(value, [message])
Утверждает, что value не является числом.
var cups = '2 cups please';
assert.isNotNumber(cups, 'how many cups');
.isFinite(value, [message])
Утверждает, что value является конечным числом. В отличие от .isNumber, это не сработает для NaN и Infinity.
var cups = 2;
assert.isFinite(cups, 'how many cups');
assert.isFinite(NaN); // throws
.isBoolean(value, [message])
Утверждает, что value является булевым значением.
var teaReady = true
, teaServed = false;
assert.isBoolean(teaReady, 'is the tea ready');
assert.isBoolean(teaServed, 'has tea been served');
.isNotBoolean(value, [message])
Утверждает, что value не является булевым значением.
var teaReady = 'yep'
, teaServed = 'nope';
assert.isNotBoolean(teaReady, 'is the tea ready');
assert.isNotBoolean(teaServed, 'has tea been served');
.typeOf(value, name, [message])
Утверждает, что тип value равен name, как определяется Object.prototype.toString.
assert.typeOf({ tea: 'chai' }, 'object', 'we have an object');
assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array');
assert.typeOf('tea', 'string', 'we have a string');
assert.typeOf(/tea/, 'regexp', 'we have a regular expression');
assert.typeOf(null, 'null', 'we have a null');
assert.typeOf(undefined, 'undefined', 'we have an undefined');
.notTypeOf(value, name, [message])
Утверждает, что тип value не равен name, как определяется Object.prototype.toString.
assert.notTypeOf('tea', 'number', 'strings are not numbers');
.instanceOf(object, constructor, [message])
Утверждает, что value является экземпляром constructor.
var Tea = function (name) { this.name = name; }
, chai = new Tea('chai');
assert.instanceOf(chai, Tea, 'chai is an instance of tea');
.notInstanceOf(object, constructor, [message])
Утверждает, что value не является экземпляром constructor.
var Tea = function (name) { this.name = name; }
, chai = new String('chai');
assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea');
.include(haystack, needle, [message])
Утверждает, что haystack включает needle.
assert.include([1,2,3], 2, 'array contains value');
assert.include('foobar', 'foo', 'string contains substring');
assert.include({ foo: 'bar', hello: 'universe' }, { foo: 'bar' }, 'object contains property');
Используется строгое равенство (===). При проверке включения значения в массив, массив ищется для элемента, строго равного заданному значению. При проверке подмножества свойств в объекте, объект ищется по заданным ключам свойств, проверяется, что каждое из них присутствует и строго равно заданному значению свойства. Например:
var obj1 = {a: 1}
, obj2 = {b: 2};
assert.include([obj1, obj2], obj1);
assert.include({foo: obj1, bar: obj2}, {foo: obj1});
assert.include({foo: obj1, bar: obj2}, {foo: obj1, bar: obj2});
.notInclude(haystack, needle, [message])
Утверждает, что haystack не включает needle.
assert.notInclude([1,2,3], 4, "array doesn't contain value");
assert.notInclude('foobar', 'baz', "string doesn't contain substring");
assert.notInclude({ foo: 'bar', hello: 'universe' }, { foo: 'baz' }, 'object doesn't contain property');
Используется строгое равенство (===). При проверке отсутствия значения в массиве, массив проверяется на отсутствие элемента, строго равного заданному значению. При проверке подмножества свойств в объекте, объект проверяется, чтобы убедиться, что хотя бы один из заданных ключей свойства отсутствует или не строго равен заданному значению свойства. Например:
var obj1 = {a: 1}
, obj2 = {b: 2};
assert.notInclude([obj1, obj2], {a: 1});
assert.notInclude({foo: obj1, bar: obj2}, {foo: {a: 1}});
assert.notInclude({foo: obj1, bar: obj2}, {foo: obj1, bar: {b: 2}});
.deepInclude(haystack, needle, [message])
Утверждает, что haystack включает needle.
var obj1 = {a: 1}
, obj2 = {b: 2};
assert.deepInclude([obj1, obj2], {a: 1});
assert.deepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}});
assert.deepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}, bar: {b: 2}});
.notDeepInclude(haystack, needle, [message])
Утверждает, что haystack не включает needle.
var obj1 = {a: 1}
, obj2 = {b: 2};
assert.notDeepInclude([obj1, obj2], {a: 9});
assert.notDeepInclude({foo: obj1, bar: obj2}, {foo: {a: 9}});
assert.notDeepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}, bar: {b: 9}});
.nestedInclude(haystack, needle, [message])
Утверждает, что ‘haystack’ включает ‘needle’.
assert.nestedInclude({'.a': {'b': 'x'}}, {'\\.a.[b]': 'x'});
assert.nestedInclude({'a': {'[b]': 'x'}}, {'a.\\[b\\]': 'x'});
.notNestedInclude(haystack, needle, [message])
Утверждает, что ‘haystack’ не включает ‘needle’.
assert.notNestedInclude({'.a': {'b': 'x'}}, {'\\.a.b': 'y'});
assert.notNestedInclude({'a': {'[b]': 'x'}}, {'a.\\[b\\]': 'y'});
.deepNestedInclude(haystack, needle, [message])
Утверждает, что ‘haystack’ включает ‘needle’ с проверкой глубокого равенства.
assert.deepNestedInclude({a: {b: [{x: 1}]}}, {'a.b[0]': {x: 1}});
assert.deepNestedInclude({'.a': {'[b]': {x: 1}}}, {'\\.a.\\[b\\]': {x: 1}});
.notDeepNestedInclude(haystack, needle, [message])
Утверждает, что ‘haystack’ не содержит ‘needle’. Может использоваться для утверждения отсутствия подмножества свойств в объекте при проверке глубокого равенства. Поддерживает использование точечной и квадратной нотации для ссылки на вложенные свойства. Символы ‘[]’ и ‘.’ в именах свойств можно экранировать с помощью двойных обратных слэшей.
assert.notDeepNestedInclude({a: {b: [{x: 1}]}}, {'a.b[0]': {y: 1}})
assert.notDeepNestedInclude({'.a': {'[b]': {x: 1}}}, {'\\.a.\\[b\\]': {y: 2}});
.ownInclude(haystack, needle, [message])
Утверждает, что ‘haystack’ содержит ‘needle’. Может использоваться для утверждения включения подмножества свойств в объекте, игнорируя унаследованные свойства.
assert.ownInclude({ a: 1 }, { a: 1 });
.notOwnInclude(haystack, needle, [message])
Утверждает, что ‘haystack’ не содержит ‘needle’. Может использоваться для утверждения отсутствия подмножества свойств в объекте, игнорируя унаследованные свойства.
Object.prototype.b = 2;
assert.notOwnInclude({ a: 1 }, { b: 2 });
.deepOwnInclude(haystack, needle, [message])
Утверждает, что ‘haystack’ содержит ‘needle’. Может использоваться для утверждения включения подмножества свойств в объекте, игнорируя унаследованные свойства и проверяя глубокое равенство.
assert.deepOwnInclude({a: {b: 2}}, {a: {b: 2}});
.notDeepOwnInclude(haystack, needle, [message])
Утверждает, что ‘haystack’ не содержит ‘needle’. Может использоваться для утверждения отсутствия подмножества свойств в объекте, игнорируя унаследованные свойства и проверяя глубокое равенство.
assert.notDeepOwnInclude({a: {b: 2}}, {a: {c: 3}});
.match(value, regexp, [message])
Утверждает, что value соответствует регулярному выражению regexp.
assert.match('foobar', /^foo/, 'regexp matches');
.notMatch(value, regexp, [message])
Утверждает, что value не соответствует регулярному выражению regexp.
assert.notMatch('foobar', /^foo/, 'regexp does not match');
.property(object, property, [message])
Утверждает, что object имеет прямое или унаследованное свойство с именем property.
assert.property({ tea: { green: 'matcha' }}, 'tea');
assert.property({ tea: { green: 'matcha' }}, 'toString');
.notProperty(object, property, [message])
Утверждает, что object не имеет прямого или унаследованного свойства с именем property.
assert.notProperty({ tea: { green: 'matcha' }}, 'coffee');
.propertyVal(object, property, value, [message])
Утверждает, что object имеет прямое или унаследованное свойство с именем property со значением value. Используется строгое сравнение (===).
assert.propertyVal({ tea: 'is good' }, 'tea', 'is good');
.notPropertyVal(object, property, value, [message])
Утверждает, что object не имеет прямого или унаследованного свойства с именем property со значением value. Используется строгое сравнение (===).
assert.notPropertyVal({ tea: 'is good' }, 'tea', 'is bad');
assert.notPropertyVal({ tea: 'is good' }, 'coffee', 'is good');
.deepPropertyVal(object, property, value, [message])
Утверждает, что object имеет прямое или унаследованное свойство с именем property со значением value. Используется глубокая проверка равенства.
assert.deepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'matcha' });
.notDeepPropertyVal(object, property, value, [message])
Утверждает, что object не имеет прямого или унаследованного свойства с именем property со значением value. Используется глубокая проверка равенства.
assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { black: 'matcha' });
assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'oolong' });
assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'coffee', { green: 'matcha' });
.nestedProperty(object, property, [message])
Утверждает, что object имеет прямое или унаследованное свойство с именем property, которое может быть строкой, использующей точку и квадратные скобки для вложенной ссылки.
assert.nestedProperty({ tea: { green: 'matcha' }}, 'tea.green');
.notNestedProperty(object, property, [message])
Утверждает, что object не имеет свойства с именем property, которое может быть строкой, использующей точку и квадратные скобки для вложенной ссылки. Свойство не может существовать ни в объекте, ни в его цепочке прототипов.
assert.notNestedProperty({ tea: { green: 'matcha' }}, 'tea.oolong');
.nestedPropertyVal(object, property, value, [message])
Утверждает, что object имеет свойство с именем property со значением, заданным value. property может использовать точку и квадратные скобки для вложенной ссылки. Используется строгое сравнение (===).
assert.nestedPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha');
.notNestedPropertyVal(object, property, value, [message])
Утверждает, что object не имеет свойства с именем property со значением, заданным value. property может использовать точку и квадратные скобки для вложенной ссылки. Используется строгое сравнение (===).
assert.notNestedPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha');
assert.notNestedPropertyVal({ tea: { green: 'matcha' }}, 'coffee.green', 'matcha');
.deepNestedPropertyVal(object, property, value, [message])
Утверждает, что object имеет свойство с именем property со значением value. property может использовать точку и квадратные скобки для вложенной ссылки. Используется глубокое сравнение.
assert.deepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { matcha: 'yum' });
.notDeepNestedPropertyVal(object, property, value, [message])
Утверждает, что object не имеет свойства с именем property со значением value. property может использовать точку и квадратные скобки для вложенной ссылки. Используется глубокое сравнение.
assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { oolong: 'yum' });
assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { matcha: 'yuck' });
assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.black', { matcha: 'yum' });
.lengthOf(object, length, [message])
Утверждает, что object имеет length или size с ожидаемым значением.
assert.lengthOf([1,2,3], 3, 'array has length of 3');
assert.lengthOf('foobar', 6, 'string has length of 6');
assert.lengthOf(new Set([1,2,3]), 3, 'set has size of 3');
assert.lengthOf(new Map([['a',1],['b',2],['c',3]]), 3, 'map has size of 3');
.hasAnyKeys(object, [keys], [message])
Утверждает, что object имеет хотя бы одно из keys ключей. Вы также можете указать один объект вместо массива keys ключей, и его ключи будут использованы в качестве ожидаемого набора ключей.
assert.hasAnyKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'iDontExist', 'baz']);
assert.hasAnyKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, iDontExist: 99, baz: 1337});
assert.hasAnyKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);
assert.hasAnyKeys(new Set([{foo: 'bar'}, 'anotherKey']), [{foo: 'bar'}, 'anotherKey']);
.hasAllKeys(object, [keys], [message])
Утверждает, что object имеет все и только все указанные keys ключи. Также можно указать один объект вместо массива keys ключей, и его ключи будут использованы в качестве ожидаемого набора ключей.
assert.hasAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'bar', 'baz']);
assert.hasAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, bar: 99, baz: 1337]);
assert.hasAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);
assert.hasAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}, 'anotherKey']);
.containsAllKeys(object, [keys], [message])
Утверждает, что object содержит все указанные keys ключи, но может содержать и дополнительные ключи, не включенные в список. Также можно указать один объект вместо массива keys ключей, и его ключи будут использованы в качестве ожидаемого набора ключей.
assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'baz']);
assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'bar', 'baz']);
assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, baz: 1337});
assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, bar: 99, baz: 1337});
assert.containsAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}]);
assert.containsAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);
assert.containsAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}]);
assert.containsAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}, 'anotherKey']);
.doesNotHaveAnyKeys(object, [keys], [message])
Утверждает, что object не имеет ни одного из keys указанных ключей. Можно также передать один объект вместо массива keys ключей, и его ключи будут использованы как ожидаемый набор ключей.
assert.doesNotHaveAnyKeys({foo: 1, bar: 2, baz: 3}, ['one', 'two', 'example']);
assert.doesNotHaveAnyKeys({foo: 1, bar: 2, baz: 3}, {one: 1, two: 2, example: 'foo'});
assert.doesNotHaveAnyKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{one: 'two'}, 'example']);
assert.doesNotHaveAnyKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{one: 'two'}, 'example']);
.doesNotHaveAllKeys(object, [keys], [message])
Утверждает, что object не имеет хотя бы одного из keys указанных ключей. Можно также передать один объект вместо массива keys ключей, и его ключи будут использованы как ожидаемый набор ключей.
assert.doesNotHaveAllKeys({foo: 1, bar: 2, baz: 3}, ['one', 'two', 'example']);
assert.doesNotHaveAllKeys({foo: 1, bar: 2, baz: 3}, {one: 1, two: 2, example: 'foo'});
assert.doesNotHaveAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{one: 'two'}, 'example']);
assert.doesNotHaveAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{one: 'two'}, 'example']);
.hasAnyDeepKeys(object, [keys], [message])
Утверждает, что object содержит по крайней мере один из keys переданных ключей. Так как множества (Sets) и отображения (Maps) могут иметь объекты в качестве ключей, вы можете использовать это утверждение для глубокого сравнения. Также вы можете указать один объект вместо массива keys, и его ключи будут использованы как ожидаемый набор ключей.
assert.hasAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {one: 'one'});
assert.hasAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), [{one: 'one'}, {two: 'two'}]);
assert.hasAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{one: 'one'}, {two: 'two'}]);
assert.hasAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {one: 'one'});
assert.hasAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {three: 'three'}]);
assert.hasAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {two: 'two'}]);
.hasAllDeepKeys(object, [keys], [message])
Утверждает, что object содержит все и только все keys переданные ключи. Так как множества (Sets) и отображения (Maps) могут иметь объекты в качестве ключей, вы можете использовать это утверждение для глубокого сравнения. Также вы можете указать один объект вместо массива keys, и его ключи будут использованы как ожидаемый набор ключей.
assert.hasAllDeepKeys(new Map([[{one: 'one'}, 'valueOne']]), {one: 'one'});
assert.hasAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{one: 'one'}, {two: 'two'}]);
assert.hasAllDeepKeys(new Set([{one: 'one'}]), {one: 'one'});
assert.hasAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {two: 'two'}]);
.containsAllDeepKeys(object, [keys], [message])
Утверждает, что object содержит все keys переданные ключи. Так как множества (Sets) и отображения (Maps) могут иметь объекты в качестве ключей, вы можете использовать это утверждение для глубокого сравнения. Также вы можете указать один объект вместо массива keys, и его ключи будут использованы как ожидаемый набор ключей.
assert.containsAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {one: 'one'});
assert.containsAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{one: 'one'}, {two: 'two'}]);
assert.containsAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {one: 'one'});
assert.containsAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {two: 'two'}]);
.doesNotHaveAnyDeepKeys(object, [keys], [message])
Утверждает, что object не содержит ни одного из keys переданных ключей. Так как множества (Sets) и отображения (Maps) могут иметь объекты в качестве ключей, вы можете использовать это утверждение для глубокого сравнения. Также вы можете указать один объект вместо массива keys, и его ключи будут использованы как ожидаемый набор ключей.
assert.doesNotHaveAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {thisDoesNot: 'exist'});
assert.doesNotHaveAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{twenty: 'twenty'}, {fifty: 'fifty'}]);
assert.doesNotHaveAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {twenty: 'twenty'});
assert.doesNotHaveAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{twenty: 'twenty'}, {fifty: 'fifty'}]);
.doesNotHaveAllDeepKeys(object, [keys], [message])
Утверждает, что object не содержит по крайней мере один из keys переданных ключей. Так как множества (Sets) и отображения (Maps) могут иметь объекты в качестве ключей, вы можете использовать это утверждение для глубокого сравнения. Также вы можете указать один объект вместо массива keys, и его ключи будут использованы как ожидаемый набор ключей.
assert.doesNotHaveAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {thisDoesNot: 'exist'});
assert.doesNotHaveAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{twenty: 'twenty'}, {one: 'one'}]);
assert.doesNotHaveAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {twenty: 'twenty'});
assert.doesNotHaveAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {fifty: 'fifty'}]);
.throws(fn, [errorLike/string/regexp], [string/regexp], [message])
Если errorLike является конструктором Error ошибки, то утверждается, что fn выбросит ошибку, являющуюся экземпляром типа errorLike. Если errorLike является экземпляром Error ошибки, утверждается, что выброшенная ошибка совпадает с errorLike. Если указано errMsgMatcher, то также утверждается, что сообщение выброшенной ошибки будет соответствовать шаблону errMsgMatcher.
assert.throws(fn, 'Error thrown must have this msg');
assert.throws(fn, /Error thrown must have a msg that matches this/);
assert.throws(fn, ReferenceError);
assert.throws(fn, errorInstance);
assert.throws(fn, ReferenceError, 'Error thrown must be a ReferenceError and have this msg');
assert.throws(fn, errorInstance, 'Error thrown must be the same errorInstance and have this msg');
assert.throws(fn, ReferenceError, /Error thrown must be a ReferenceError and match this/);
assert.throws(fn, errorInstance, /Error thrown must be the same errorInstance and match this/);
.doesNotThrow(fn, [errorLike/string/regexp], [string/regexp], [message])
Если errorLike является конструктором Error ошибки, утверждается, что fn не выбросит ошибку, являющуюся экземпляром типа errorLike. Если errorLike является экземпляром Error ошибки, утверждается, что выброшенная ошибка не совпадает с errorLike. Если указано errMsgMatcher, то также утверждается, что сообщение выброшенной ошибки не будет соответствовать шаблону errMsgMatcher.
assert.doesNotThrow(fn, 'Any Error thrown must not have this message');
assert.doesNotThrow(fn, /Any Error thrown must not match this/);
assert.doesNotThrow(fn, Error);
assert.doesNotThrow(fn, errorInstance);
assert.doesNotThrow(fn, Error, 'Error must not have this message');
assert.doesNotThrow(fn, errorInstance, 'Error must not have this message');
assert.doesNotThrow(fn, Error, /Error must not match this/);
assert.doesNotThrow(fn, errorInstance, /Error must not match this/);
.operator(val1, operator, val2, [message])
Сравнивает два значения с использованием operator.
assert.operator(1, '<', 2, 'everything is ok');
assert.operator(1, '>', 2, 'this will fail');
.closeTo(actual, expected, delta, [message])
Утверждает, что значение совпадает expected, с точностью до +/- delta.
assert.closeTo(1.5, 1, 0.5, 'numbers are close');
.approximately(actual, expected, delta, [message])
Утверждает, что значение совпадает expected, с точностью до +/- delta.
assert.approximately(1.5, 1, 0.5, 'numbers are close');
.sameMembers(set1, set2, [message])
Утверждает, что set1 и set2 имеют одинаковые элементы в любом порядке. Использует строгое сравнение (===).
assert.sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members');
.notSameMembers(set1, set2, [message])
Утверждает, что set1 и set2 не имеют одинаковых элементов в любом порядке. Используется строгое сравнение (===).
assert.notSameMembers([ 1, 2, 3 ], [ 5, 1, 3 ], 'not same members');
.sameDeepMembers(set1, set2, [message])
Утверждает, что set1 и set2 имеют одинаковые элементы в любом порядке. Используется глубокое сравнение.
assert.sameDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [{ b: 2 }, { a: 1 }, { c: 3 }], 'same deep members');
.notSameDeepMembers(set1, set2, [message])
Утверждает, что set1 и set2 не имеют одинаковых элементов в любом порядке. Используется глубокое сравнение.
assert.notSameDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [{ b: 2 }, { a: 1 }, { f: 5 }], 'not same deep members');
.sameOrderedMembers(set1, set2, [message])
Утверждает, что set1 и set2 имеют одинаковые элементы в том же порядке. Используется строгое сравнение (===).
assert.sameOrderedMembers([ 1, 2, 3 ], [ 1, 2, 3 ], 'same ordered members');
.notSameOrderedMembers(set1, set2, [message])
Утверждает, что set1 и set2 не имеют одинаковых элементов в том же порядке. Используется строгое сравнение (===).
assert.notSameOrderedMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'not same ordered members');
.sameDeepOrderedMembers(set1, set2, [message])
Утверждает, что set1 и set2 имеют одинаковые элементы в том же порядке. Используется глубокое сравнение.
assert.sameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 }, { c: 3 } ], 'same deep ordered members');
.notSameDeepOrderedMembers(set1, set2, [message])
Утверждает, что set1 и set2 не имеют одинаковых элементов в том же порядке. Используется глубокое сравнение.
assert.notSameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 }, { z: 5 } ], 'not same deep ordered members');
assert.notSameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 }, { c: 3 } ], 'not same deep ordered members');
.includeMembers(superset, subset, [message])
Утверждает, что subset содержится в superset в любом порядке. Используется строгое сравнение (===). Дубликаты игнорируются.
assert.includeMembers([ 1, 2, 3 ], [ 2, 1, 2 ], 'include members');
.notIncludeMembers(superset, subset, [message])
Утверждает, что subset не содержится в superset в любом порядке. Используется строгое сравнение (===). Дубликаты игнорируются.
assert.notIncludeMembers([ 1, 2, 3 ], [ 5, 1 ], 'not include members');
.includeDeepMembers(superset, subset, [message])
Утверждает, что subset содержится в superset в любом порядке. Используется глубокое сравнение. Дубликаты игнорируются.
assert.includeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 }, { b: 2 } ], 'include deep members');
.notIncludeDeepMembers(superset, subset, [message])
Утверждает, что subset не содержится в superset в любом порядке. Используется глубокое сравнение. Дубликаты игнорируются.
assert.notIncludeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { f: 5 } ], 'not include deep members');
.includeOrderedMembers(superset, subset, [message])
Утверждает, что subset содержится в superset в том же порядке, начиная с первого элемента в superset. Используется строгое сравнение (===).
assert.includeOrderedMembers([ 1, 2, 3 ], [ 1, 2 ], 'include ordered members');
.notIncludeOrderedMembers(superset, subset, [message])
Утверждает, что subset не содержится в superset в том же порядке, начиная с первого элемента в superset. Используется строгое сравнение (===).
assert.notIncludeOrderedMembers([ 1, 2, 3 ], [ 2, 1 ], 'not include ordered members');
assert.notIncludeOrderedMembers([ 1, 2, 3 ], [ 2, 3 ], 'not include ordered members');
.includeDeepOrderedMembers(superset, subset, [message])
Утверждает, что subset содержится в superset в том же порядке, начиная с первого элемента в superset. Используется глубокое сравнение.
assert.includeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 } ], 'include deep ordered members');
.notIncludeDeepOrderedMembers(superset, subset, [message])
Утверждает, что subset не входит в superset в том же порядке, начиная с первого элемента в superset. Используется глубокая проверка равенства.
assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { f: 5 } ], 'not include deep ordered members');
assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 } ], 'not include deep ordered members');
assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { c: 3 } ], 'not include deep ordered members');
.oneOf(inList, list, [message])
Утверждает, что значение inList, которое не является объектом и не является массивом, присутствует в плоском массиве list.
assert.oneOf(1, [ 2, 1 ], 'Not found in list');
.changes(function, object, property, [message])
Утверждает, что функция изменяет значение свойства.
var obj = { val: 10 };
var fn = function() { obj.val = 22 };
assert.changes(fn, obj, 'val');
.changesBy(function, object, property, delta, [message])
Утверждает, что функция изменяет значение свойства на определённую величину (delta).
var obj = { val: 10 };
var fn = function() { obj.val += 2 };
assert.changesBy(fn, obj, 'val', 2);
.doesNotChange(function, object, property, [message])
Утверждает, что функция не изменяет значение свойства.
var obj = { val: 10 };
var fn = function() { console.log('foo'); };
assert.doesNotChange(fn, obj, 'val');
.changesButNotBy(function, object, property, delta, [message])
Утверждает, что функция не изменяет значение свойства или значение возвращаемого функцией значения на определённую величину (delta).
var obj = { val: 10 };
var fn = function() { obj.val += 10 };
assert.changesButNotBy(fn, obj, 'val', 5);
.increases(function, object, property, [message])
Утверждает, что функция увеличивает числовое свойство объекта.
var obj = { val: 10 };
var fn = function() { obj.val = 13 };
assert.increases(fn, obj, 'val');
.increasesBy(function, object, property, delta, [message])
Утверждает, что функция увеличивает числовое свойство объекта или возвращаемое функцией значение на определённую величину (delta).
var obj = { val: 10 };
var fn = function() { obj.val += 10 };
assert.increasesBy(fn, obj, 'val', 10);
.doesNotIncrease(function, object, property, [message])
Утверждает, что функция не увеличивает числовое свойство объекта.
var obj = { val: 10 };
var fn = function() { obj.val = 8 };
assert.doesNotIncrease(fn, obj, 'val');
.increasesButNotBy(function, object, property, delta, [message])
Утверждает, что функция не увеличивает числовое свойство объекта или возвращаемое функцией значение на определённую величину (delta).
var obj = { val: 10 };
var fn = function() { obj.val = 15 };
assert.increasesButNotBy(fn, obj, 'val', 10);
.decreases(function, object, property, [message])
Утверждает, что функция уменьшает числовое свойство объекта.
var obj = { val: 10 };
var fn = function() { obj.val = 5 };
assert.decreases(fn, obj, 'val');
.decreasesBy(function, object, property, delta, [message])
Утверждает, что функция уменьшает числовое свойство объекта или возвращаемое значение функции на заданное значение (разницу)
var obj = { val: 10 };
var fn = function() { obj.val -= 5 };
assert.decreasesBy(fn, obj, 'val', 5);
.doesNotDecrease(function, object, property, [message])
Утверждает, что функция не уменьшает числовое свойство объекта.
var obj = { val: 10 };
var fn = function() { obj.val = 15 };
assert.doesNotDecrease(fn, obj, 'val');
.doesNotDecreaseBy(function, object, property, delta, [message])
Утверждает, что функция не уменьшает числовое свойство объекта или возвращаемое значение функции на заданное значение (разницу)
var obj = { val: 10 };
var fn = function() { obj.val = 5 };
assert.doesNotDecreaseBy(fn, obj, 'val', 1);
.decreasesButNotBy(function, object, property, delta, [message])
Утверждает, что функция не уменьшает числовое свойство объекта или возвращаемое значение функции на заданное значение (разницу)
var obj = { val: 10 };
var fn = function() { obj.val = 5 };
assert.decreasesButNotBy(fn, obj, 'val', 1);
.ifError(object)
Утверждает, что значение не является ложным значением, и генерирует исключение, если значение является истинным значением. Это добавлено, чтобы позволить chai быть прямым заменителем класса assert Node.
var err = new Error('I am a custom error');
assert.ifError(err); // Rethrows err!
.isExtensible(object)
Утверждает, что object является расширяемым (к нему можно добавлять новые свойства).
assert.isExtensible({});
.isNotExtensible(object)
Утверждает, что object является не расширяемым.
var nonExtensibleObject = Object.preventExtensions({});
var sealedObject = Object.seal({});
var frozenObject = Object.freeze({});
assert.isNotExtensible(nonExtensibleObject);
assert.isNotExtensible(sealedObject);
assert.isNotExtensible(frozenObject);
.isSealed(object)
Утверждает, что object является запечатанным (к нему нельзя добавлять новые свойства, и существующие свойства нельзя удалить).
var sealedObject = Object.seal({});
var frozenObject = Object.seal({});
assert.isSealed(sealedObject);
assert.isSealed(frozenObject);
.isNotSealed(object)
Утверждает, что object является не запечатанным.
assert.isNotSealed({});
.isFrozen(object)
Утверждает, что object является замороженным (к нему нельзя добавлять новые свойства, и существующие свойства нельзя изменять).
var frozenObject = Object.freeze({});
assert.frozen(frozenObject);
.isNotFrozen(object)
Утверждает, что object является не замороженным.
assert.isNotFrozen({});
.isEmpty(target)
Утверждает, что целевой объект не содержит никаких значений. Для массивов и строк проверяется свойство length. Для экземпляров Map и Set проверяется свойство size. Для не-функциональных объектов подсчитывается количество собственных перечисляемых строковых ключей.
assert.isEmpty([]);
assert.isEmpty('');
assert.isEmpty(new Map);
assert.isEmpty({});
.isNotEmpty(target)
Утверждает, что целевой объект содержит значения. Для массивов и строк проверяется свойство length. Для экземпляров Map и Set проверяется свойство size. Для не-функциональных объектов подсчитывается количество собственных перечисляемых строковых ключей.
assert.isNotEmpty([1, 2]);
assert.isNotEmpty('34');
assert.isNotEmpty(new Set([5, 6]));
assert.isNotEmpty({ key: 7 });
© 2017 Chai.js Assertion Library
Licensed under the MIT License.
https://www.chaijs.com/api/assert/
