chai with sinon-chai, dirty-chai, chai-as-promised with mixed features
Now supports Chai 4.x
npm install ultimate-chai --save-dev
const chai = require('ultimate-chai');
const expect = chai.expect;
expect(true).to.be.true();
(or)
const expect = require('ultimate-chai').expect;
expect(true).to.be.true();
The following built-in assertions are modified by this plugin to now use the function-call form:
| method | assertion |
|---|---|
| ok | expect('sample').to.be.ok() |
| true | expect(true).to.be.true() |
| false | expect(false).to.be.true() |
| null | expect(null).to.be.null() |
| undefined | expect(undefined).to.be.true() |
| exist | expect('sample').to.exist() |
| empty | expect('').to.empty() |
| arguments | arguments() |
| Arguments | Arguments() |
it('should have ok method from dirty-chai', (done) => {
expect('ok').to.be.ok();
done();
});
it('should have false method from dirty-chai', (done) => {
expect(true).to.be.true.and.not.false();
done();
});
it('should have true method from dirty-chai', (done) => {
expect(true).to.be.true();
done();
});
it('should have null method from dirty-chai', (done) => {
expect(null).to.be.null();
done();
});
it('should have exist method from dirty-chai', (done) => {
expect(undefined).to.be.undefined();
done();
});
it('should have exist method from dirty-chai', (done) => {
expect('test').to.exist();
done();
});
it('should have empty method from dirty-chai', (done) => {
expect('').to.be.empty();
done();
});
it('should have empty method from dirty-chai', (done) => {
expect('').to.be.empty();
done();
});
Please note there is () invocation at end
return promise.should.be.fulfilled();
return promise.should.eventually.deep.equal("foo");
return promise.should.become("foo"); // same as `.eventually.deep.equal`
return promise.should.be.rejected();
return promise.should.be.rejectedWith(Error); // other variants of Chai's `throw` assertion work too.
const sampleSuccess = () => new Promise((resolve, reject) => {
setTimeout(function(){
resolve({foo: "bar"});
},100);
});
const sampleReject = () => new Promise((resolve, reject) => {
setTimeout(function(){
reject(new Error('error'));
},100);
});
it('should have eventually method from chai-as-promised', () => {
return expect(sampleSuccess()).to.eventually.have.property("foo");
});
it('should have fulfilled method from chai-as-promised', () => {
return expect(sampleSuccess()).to.be.fulfilled();
});
it('should have become method from chai-as-promised', () => {
return expect(sampleSuccess()).to.become({foo: "bar"});
});
it('should have rejected method from chai-as-promised', () => {
return expect(sampleReject()).to.be.rejected();
});
it('should have rejected method from chai-as-promised', () => {
return expect(sampleReject()).to.be.rejectedWith(Error);
});
please note the difference all methods ends with () invocation
All of your favorite Sinon.JS assertions made their way into Sinon–Chai. We show the should syntax here; the expect
equivalent is also available.
| Sinon.JS property/method | Sinon–Chai assertion |
|---|---|
| called | spy.should.have.been.called() |
| callCount | spy.should.have.callCount(n) |
| calledOnce | spy.should.have.been.calledOnce() |
| calledTwice | spy.should.have.been.calledTwice() |
| calledThrice | spy.should.have.been.calledThrice() |
| calledBefore | spy1.should.have.been.calledBefore(spy2) |
| calledAfter | spy1.should.have.been.calledAfter(spy2) |
| calledWithNew | spy.should.have.been.calledWithNew() |
| alwaysCalledWithNew | spy.should.always.have.been.calledWithNew() |
| calledOn | spy.should.have.been.calledOn(context) |
| alwaysCalledOn | spy.should.always.have.been.calledOn(context) |
| calledWith | spy.should.have.been.calledWith(...args) |
| alwaysCalledWith | spy.should.always.have.been.calledWith(...args) |
| calledWithExactly | spy.should.have.been.calledWithExactly(...args) |
| alwaysCalledWithExactly | spy.should.always.have.been.calledWithExactly(...args) |
| calledWithMatch | spy.should.have.been.calledWithMatch(...args) |
| alwaysCalledWithMatch | spy.should.always.have.been.calledWithMatch(...args) |
| returned | spy.should.have.returned(returnVal) |
| alwaysReturned | spy.should.have.always.returned(returnVal) |
| threw | spy.should.have.thrown(errorObjOrErrorTypeStringOrNothing) |
| alwaysThrew | spy.should.have.always.thrown(errorObjOrErrorTypeStringOrNothing) |
const testspy = sinon.spy();
it('should have called method from sinon-chai', () => {
testspy("foo");
expect(testspy).to.have.been.called();
});
it('should have calledWith method from sinon-chai', () => {
testspy("foo");
expect(testspy).to.have.been.calledWith("foo");
});
it('should have calledWith method from sinon-chai', () => {
const callCountSpy = sinon.spy();
callCountSpy();
callCountSpy('foo');
callCountSpy('wow');
expect(callCountSpy).to.have.callCount(3);
});
it('should have calledOnce method from sinon-chai', () => {
const callCountSpy = sinon.spy();
callCountSpy();
expect(callCountSpy).to.have.been.calledOnce();
});
it('should have calledTwice method from sinon-chai', () => {
const callCountSpy = sinon.spy();
callCountSpy();
callCountSpy('foo');
expect(callCountSpy).to.have.been.calledTwice();
});
it('should have calledThrice method from sinon-chai', () => {
const callCountSpy = sinon.spy();
callCountSpy();
callCountSpy('foo');
callCountSpy('bar');
expect(callCountSpy).to.have.been.calledThrice();
});
it('should have calledBefore method from sinon-chai', () => {
const spy1 = sinon.spy();
const spy2 = sinon.spy();
spy1();
spy2();
expect(spy1).to.have.been.calledBefore(spy2);
});
it('should have calledBefore method from sinon-chai', () => {
const spy1 = sinon.spy();
const spy2 = sinon.spy();
spy1();
spy2();
expect(spy1).to.have.been.calledBefore(spy2);
});
it('should have calledAfter method from sinon-chai', () => {
const spy1 = sinon.spy();
const spy2 = sinon.spy();
spy1();
spy2();
expect(spy2).to.have.been.calledAfter(spy1);
});
it('should have calledAfter method from sinon-chai', () => {
const spy = sinon.spy();
new spy();
expect(spy).to.have.been.calledWithNew();
});
it('should have alwaysCalledWithNew method from sinon-chai', () => {
const spy = sinon.spy();
new spy();
new spy();
expect(spy).to.always.have.been.calledWithNew();
});
you still can use Chai 3.x with ultimate-chai 3.x