アサート
assert スタイルは、node.js に含まれる assert モジュールと非常によく似ており、少しだけ機能が追加されています。3 つのスタイルオプションの中で、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])
失敗をスローします。Node.js の assert モジュールと互換性があります。
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 が false であることをアサートします。
var teaServed = false;
assert.isFalse(teaServed, 'no tea yet? hmm...');
.isNotFalse(value, [message])
value が false でないことをアサートします。
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’ 型のオブジェクトであること (Object.prototype.toString で判別) をアサートします。*サブクラス化されたオブジェクトは一致しません。*
var selection = { name: 'Chai', serve: 'with spices' };
assert.isObject(selection, 'tea selection is an object');
.isNotObject(value, [message])
value が ‘Object’ 型のオブジェクト*でない*こと (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])
Object.prototype.toString で判定される value の型が name であることをアサートします。
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])
Object.prototype.toString で判定される value の型が name *でない*ことをアサートします。
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');
厳密等価 (===) が使用されます。配列に値が含まれないかをアサートする場合、配列内で指定された値と厳密に等しい要素が存在しないことが確認されます。オブジェクトにプロパティのサブセットが含まれないかをアサートする場合、オブジェクト内で指定されたプロパティキーの少なくとも1つが存在しないか、指定されたプロパティ値と厳密に等しくないことが確認されます。例えば
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」が含まれることをアサートします。オブジェクトにプロパティのサブセットが含まれることをアサートするために使用できます。ネストされたプロパティを参照するために、ドット表記とブラケット表記を使用できます。プロパティ名に含まれる「[]」と「.」は、バックスラッシュを2つ重ねてエスケープできます。
assert.nestedInclude({'.a': {'b': 'x'}}, {'\\.a.[b]': 'x'});
assert.nestedInclude({'a': {'[b]': 'x'}}, {'a.\\[b\\]': 'x'});
.notNestedInclude(haystack, needle, [message])
「haystack」に「needle」が含まれないことをアサートします。オブジェクトにプロパティのサブセットが含まれないことをアサートするために使用できます。ネストされたプロパティを参照するために、ドット表記とブラケット表記を使用できます。プロパティ名に含まれる「[]」と「.」は、バックスラッシュを2つ重ねてエスケープできます。
assert.notNestedInclude({'.a': {'b': 'x'}}, {'\\.a.b': 'y'});
assert.notNestedInclude({'a': {'[b]': 'x'}}, {'a.\\[b\\]': 'y'});
.deepNestedInclude(haystack, needle, [message])
「haystack」に「needle」が含まれることをアサートします。深い等価性をチェックしながら、オブジェクトにプロパティのサブセットが含まれることをアサートするために使用できます。ネストされたプロパティを参照するために、ドット表記とブラケット表記を使用できます。プロパティ名に含まれる「[]」と「.」は、バックスラッシュを2つ重ねてエスケープできます。
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」が含まれないことをアサートします。深い等価性をチェックしながら、オブジェクトにプロパティのサブセットが含まれないことをアサートするために使用できます。ネストされたプロパティを参照するために、ドット表記とブラケット表記を使用できます。プロパティ名に含まれる「[]」と「.」は、バックスラッシュを2つ重ねてエスケープできます。
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 の少なくとも1つを持つことをアサートします。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 の少なくとも1つを *持たない* ことをアサートします。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 の少なくとも1つを持つことをアサートします。Set と Map はオブジェクトをキーとして持つことができるため、このアサーションを使用して深い比較を実行できます。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 のすべてを、かつすべてのみを持つことをアサートします。Set と Map はオブジェクトをキーとして持つことができるため、このアサーションを使用して深い比較を実行できます。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 のすべてを含むことをアサートします。Set と Map はオブジェクトをキーとして持つことができるため、このアサーションを使用して深い比較を実行できます。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 のいずれも *持たない* ことをアサートします。Set と Map はオブジェクトをキーとして持つことができるため、このアサーションを使用して深い比較を実行できます。 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 の少なくとも1つを *持たない* ことをアサートします。Set と Map はオブジェクトをキーとして持つことができるため、このアサーションを使用して深い比較を実行できます。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 を使用して2つの値を比較します。
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])
関数がプロパティの値を指定された量（デルタ）だけ変更することをアサートします。
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])
関数がプロパティの値または関数の戻り値を指定された量（デルタ）だけ変更しないことをアサートします。
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])
関数が数値オブジェクトプロパティまたは関数の戻り値を指定された量（デルタ）だけ増加させることをアサートします。
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])
関数が数値オブジェクトプロパティまたは関数の戻り値を指定された量（デルタ）だけ増加させないことをアサートします。
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 を Node の assert クラスのドロップイン置換にするために追加されました。
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 });