アサーションライブラリChaiのMatcher一覧

const chai = require('chai');
const assert = chai.assert;

describe('Array', function() {
    it('should start empty', function() {
        const arr = [];
        assert.equal(arr.length, 0); // Chaiのassertを使って評価
    });
});

const assert = require('chai').assert;

assert.equal(5, 5, '値が一致する');
assert.strictEqual(5, 5, '厳密に一致する');
assert.isTrue(true, '値がtrueである');
assert.isArray([1, 2, 3], 'これは配列である');
assert.lengthOf([1, 2, 3], 3, '配列の長さは3である');

const expect = require('chai').expect;

expect(5).to.equal(5);
expect('hello').to.be.a('string');
expect([1, 2, 3]).to.have.lengthOf(3);
expect({ a: 1 }).to.have.property('a');
expect([1, 2, 3]).to.include(2);

const should = require('chai').should();  // `.should()` を実行して有効化

(5).should.equal(5);
'hello'.should.be.a('string');
[1, 2, 3].should.have.lengthOf(3);
({ a: 1 }).should.have.property('a');
[1, 2, 3].should.include(2);

let foo;
foo.should.equal(5);  // エラー発生！

expect(5).to.be.a('number');

expect(true).to.be.true;
expect(5).to.be.equal(5);

expect(obj).to.have.been.calledOnce;

expect('hello').to.be.is.a('string');

expect(foo).to.be.that.deep.equal(bar);

expect(obj).to.have.property('name').which.is.a('string');

expect(5).to.be.above(3).and.below(10);

expect({name: 'John'}).to.has.property('name');

expect([1, 2, 3]).to.have.lengthOf(3);

expect([1, 2]).to.have.same.members([1, 2]);

expect(5).to.be.above(3).but.not.equal(5);

expect(obj).to.have.property('foo').that.does.not.throw();

expect(foo).to.have.property('bar').still.equal('baz');

expect(foo).to.be.a('string').also.to.have.lengthOf(3);

expect(foo).to.not.be.empty;

expect(2 + 2).to.equal(4);  // ✅ OK (2 + 2 は 4 に等しい)
expect("hello").to.equal("hello");  // ✅ OK (文字列が同じ)
expect(true).to.equal(true);  // ✅ OK (ブール値が同じ)

// NG の例（型が異なるため）
expect(2).to.equal("2");  // ❌ 型が違うのでエラー

expect({ a: 1 }).to.deep.equal({ a: 1 });  // ✅ OK (オブジェクトのプロパティが一致)

// 配列の比較
expect([1, 2, 3]).to.deep.equal([1, 2, 3]);  // ✅ OK (配列の内容が一致)

// NG の例（異なるオブジェクト参照）
const obj1 = { a: 1 };
const obj2 = obj1;  // 参照が同じ
const obj3 = { a: 1 };  // 内容は同じだが別のオブジェクト

expect(obj1).to.equal(obj2);  // ✅ OK (同じ参照)
expect(obj1).to.equal(obj3);  // ❌ エラー（参照が違うため）
expect(obj1).to.deep.equal(obj3);  // ✅ OK（内容が同じ）

expect({ a: 1 }).to.eql({ a: 1 });  // ✅ OK
expect([1, 2, 3]).to.eql([1, 2, 3]);  // ✅ OK

// `.deep.equal` と同じ動作
expect({ a: 1 }).to.deep.equal({ a: 1 });  // ✅ OK
expect({ a: 1 }).to.eql({ a: 1 });  // ✅ OK（`deep.equal` のエイリアス）

expect(10).to.be.above(5);  // ✅ OK (10 > 5)
expect(100).to.be.greaterThan(50);  // ✅ OK (100 > 50)

// NG の例（10 は 10 より大きくない）
expect(10).to.be.above(10);  // ❌ エラー

expect(10).to.be.at.least(10);  // ✅ OK (10 >= 10)
expect(20).to.be.at.least(10);  // ✅ OK (20 >= 10)

// NG の例（9 は 10 以上ではない）
expect(9).to.be.at.least(10);  // ❌ エラー

expect(5).to.be.below(10);  // ✅ OK (5 < 10)
expect(3).to.be.lessThan(5);  // ✅ OK (3 < 5)

// NG の例（5 は 5 未満ではない）
expect(5).to.be.below(5);  // ❌ エラー

expect(5).to.be.at.most(5);  // ✅ OK (5 <= 5)
expect(6).to.be.at.most(5);  // ❌ 6 は 5 以下ではないのでエラー

expect(true).to.be.true;  // ✅ OK
expect(false).to.be.true;  // ❌ エラー

expect(false).to.be.false;  // ✅ OK
expect(true).to.be.false;  // ❌ エラー

expect(1).to.be.ok;  // ✅ OK (1 は真)
expect(false).to.be.ok;  // ❌ エラー

expect(0).to.not.be.ok;  // ✅ OK (0 は偽)
expect(null).to.not.be.ok;  // ✅ OK (null は偽)
expect(1).to.not.be.ok;  // ❌ エラー

expect(true).to.be.a('boolean');  // ✅ OK
expect("true").to.be.a('boolean');  // ❌ エラー（文字列はbooleanではない）

expect(42).to.be.a('number');  // ✅ OK
expect("Hello").to.be.a('string');  // ✅ OK
expect(true).to.be.a('boolean');  // ✅ OK

expect(42).to.be.an('number');  // ✅ OK
expect("Hello").to.be.an('string');  // ✅ OK
expect([1, 2, 3]).to.be.an('array');  // ✅ OK

class MyClass {}
const obj = new MyClass();
expect(obj).to.be.instanceOf(MyClass);  // ✅ OK
expect({}).to.be.instanceOf(Object);  // ✅ OK

expect(42).to.have.a.property('typeof', 'number');  // ✅ OK
expect('Hello').to.have.a.property('typeof', 'string');  // ✅ OK
expect(true).to.have.a.property('typeof', 'boolean');  // ✅ OK

expect([1, 2, 3]).to.have.lengthOf(3);  // ✅ OK
expect("Hello").to.have.lengthOf(5);  // ✅ OK
expect([].length).to.have.lengthOf(0);  // ✅ OK

expect([1, 2, 3]).to.include(2);  // ✅ OK
expect({ a: 1, b: 2 }).to.include({ a: 1 });  // ✅ OK

expect([1, 2, 3]).to.not.include(4);  // ✅ OK
expect({ a: 1 }).to.not.include({ b: 2 });  // ✅ OK

expect({ a: 1, b: 2 }).to.have.property('a');  // ✅ OK
expect({ a: 1 }).to.have.property('b');  // ❌ エラー（プロパティ 'b' がない）

const func = () => { throw new Error('Something went wrong!'); };
expect(func).to.throw();  // ✅ OK
expect(func).to.throw('Something went wrong!');  // ✅ OK

const func = () => { throw new TypeError('Invalid type'); };
expect(func).to.throw(TypeError);  // ✅ OK

const func = () => { throw new TypeError('Invalid type'); };
expect(func).to.throw(new TypeError('Invalid type'));  // ✅ OK

expect("hello world").to.match(/^hello/);  // "hello" で始まる
expect("test123").to.match(/\d+$/);  // 数字で終わる

expect(10).to.satisfy(num => num % 2 === 0);  // 偶数かどうか
expect("chai").to.satisfy(str => str.length === 4);  // 長さが4文字か

expect(5).to.be.oneOf([1, 2, 3, 5, 7]);  // 5は配列に含まれる
expect("banana").to.be.oneOf(["apple", "banana", "cherry"]);  // "banana" が含まれる