The BDD style is exposed through expect
or should
interfaces. In both
scenarios, you chain together natural language assertions.
// expect
var expect = require('chai').expect;
expect(foo).to.equal('bar');
// should
var should = require('chai').should();
foo.should.equal('bar');
Differences
The expect
interface provides a function as a starting point for chaining
your language assertions. It works on both node.js and in the browser.
The should
interface extends Object.prototype
to provide a single getter as
the starting point for your language assertions. Most browser don't like
extensions to Object.prototype
so it is not recommended for browser use.
View Source
Assertion.prototype.__defineGetter__('to', function () {
return this;
});
View Source
Assertion.prototype.__defineGetter__('be', function () {
return this;
});
View Source
Assertion.prototype.__defineGetter__('an', function () {
return this;
});
View Source
Assertion.prototype.__defineGetter__('is', function () {
return this;
});
View Source
Assertion.prototype.__defineGetter__('and', function () {
return this;
});
View Source
Assertion.prototype.__defineGetter__('have', function () {
return this;
});
View Source
Assertion.prototype.__defineGetter__('with', function () {
return this;
});
Negates any of assertions following in the chain.
View Source
Assertion.prototype.__defineGetter__('not', function () {
this.negate = true;
return this;
});
Assert object truthiness.
expect('everthing').to.be.ok;
expect(false).to.not.be.ok;
expect(undefined).to.not.be.ok;
expect(null).to.not.be.ok;
View Source
Assertion.prototype.__defineGetter__('ok', function () {
this.assert(
this.obj
, 'expected ' + this.inspect + ' to be truthy'
, 'expected ' + this.inspect + ' to be falsey');
return this;
});
View Source
Assertion.prototype.__defineGetter__('true', function () {
this.assert(
true === this.obj
, 'expected ' + this.inspect + ' to be true'
, 'expected ' + this.inspect + ' to be false');
return this;
});
View Source
Assertion.prototype.__defineGetter__('false', function () {
this.assert(
false === this.obj
, 'expected ' + this.inspect + ' to be false'
, 'expected ' + this.inspect + ' to be true');
return this;
});
Assert object exists (null).
var foo = 'hi'
, bar;
expect(foo).to.exist;
expect(bar).to.not.exist;
View Source
Assertion.prototype.__defineGetter__('exist', function () {
this.assert(
null != this.obj
, 'expected ' + this.inspect + ' to exist'
, 'expected ' + this.inspect + ' to not exist');
return this;
});
Assert object's length to be 0.
expect([]).to.be.empty;
View Source
Assertion.prototype.__defineGetter__('empty', function () {
new Assertion(this.obj).to.have.property('length');
this.assert(
0 === this.obj.length
, 'expected ' + this.inspect + ' to be empty'
, 'expected ' + this.inspect + ' not to be empty');
return this;
});
Assert object is an instanceof arguments.
function test () {
expect(arguments).to.be.arguments;
}
View Source
Assertion.prototype.__defineGetter__('arguments', function () {
this.assert(
'[object Arguments]' == Object.prototype.toString.call(this.obj)
, 'expected ' + this.inspect + ' to be arguments'
, 'expected ' + this.inspect + ' to not be arguments');
return this;
});
Assertion.prototype.equal()
Assert strict equality.
expect('hello').to.equal('hello');
View Source
Assertion.prototype.equal = function (val) {
this.assert(
val === this.obj
, 'expected ' + this.inspect + ' to equal ' + inspect(val)
, 'expected ' + this.inspect + ' to not equal ' + inspect(val));
return this;
};
Assertion.prototype.eql()
Assert deep equality.
expect({ foo: 'bar' }).to.eql({ foo: 'bar' });
View Source
Assertion.prototype.eql = function (obj) {
this.assert(
eql(obj, this.obj)
, 'expected ' + this.inspect + ' to equal ' + inspect(obj)
, 'expected ' + this.inspect + ' to not equal ' + inspect(obj));
return this;
};
Assertion.prototype.above()
Assert greater than value
.
expect(10).to.be.above(5);
View Source
Assertion.prototype.above = function (val) {
this.assert(
this.obj > val
, 'expected ' + this.inspect + ' to be above ' + val
, 'expected ' + this.inspect + ' to be below ' + val);
return this;
};
Assertion.prototype.below()
Assert less than value
.
expect(5).to.be.below(10);
View Source
Assertion.prototype.below = function (val) {
this.assert(
this.obj < val
, 'expected ' + this.inspect + ' to be below ' + val
, 'expected ' + this.inspect + ' to be above ' + val);
return this;
};
Assertion.prototype.within()
Assert that a number is within a range.
expect(7).to.be.within(5,10);
View Source
Assertion.prototype.within = function (start, finish) {
var range = start + '..' + finish;
this.assert(
this.obj >= start && this.obj <= finish
, 'expected ' + this.inspect + ' to be within ' + range
, 'expected ' + this.inspect + ' to not be within ' + range);
return this;
};
Assertion.prototype.a()
Assert typeof.
expect('test').to.be.a('string');
View Source
Assertion.prototype.a = function (type) {
this.assert(
type == typeof this.obj
, 'expected ' + this.inspect + ' to be a ' + type
, 'expected ' + this.inspect + ' not to be a ' + type);
return this;
};
Assertion.prototype.instanceof()
Assert instanceof.
expect(42).to.be.instanceof(Number);
expect([4,2]).to.be.instanceof(Array);
View Source
Assertion.prototype.instanceof = function (constructor) {
var name = constructor.name;
this.assert(
this.obj instanceof constructor
, 'expected ' + this.inspect + ' to be an instance of ' + name
, 'expected ' + this.inspect + ' to not be an instance of ' + name);
return this;
};
Assertion.prototype.respondTo()
Assert that method
is a function.
var res = { send: function () {} };
expect(res).to.respondTo('send');
View Source
Assertion.prototype.respondTo = function (method) {
this.assert(
'function' == typeof this.obj[method]
, 'expected ' + this.inspect + ' to respond to ' + method + '()'
, 'expected ' + this.inspect + ' to not respond to ' + method + '()');
return this;
}
Assertion.prototype.property()
Assert that property of name
exists,
optionally with value
.
var obj = { foo: 'bar' }
expect(obj).to.have.property('foo');
expect(obj).to.have.property('foo', 'bar');
expect(obj).to.have.property('foo').to.be.a('string');
View Source
Assertion.prototype.property = function (name, val) {
if (this.negate && undefined !== val) {
if (undefined === this.obj[name]) {
throw new Error(this.inspect + ' has no property ' + inspect(name));
}
} else {
this.assert(
undefined !== this.obj[name]
, 'expected ' + this.inspect + ' to have a property ' + inspect(name)
, 'expected ' + this.inspect + ' to not have property ' + inspect(name));
}
if (undefined !== val) {
this.assert(
val === this.obj[name]
, 'expected ' + this.inspect + ' to have a property ' + inspect(name) + ' of ' +
inspect(val) + ', but got ' + inspect(this.obj[name])
, 'expected ' + this.inspect + ' to not have a property ' + inspect(name) + ' of ' + inspect(val));
}
this.obj = this.obj[name];
return this;
};
Assertion.prototype.ownProperty()
Assert that has own property by name
.
expect('test').to.have.ownProperty('length');
View Source
Assertion.prototype.ownProperty = function (name) {
this.assert(
this.obj.hasOwnProperty(name)
, 'expected ' + this.inspect + ' to have own property ' + inspect(name)
, 'expected ' + this.inspect + ' to not have own property ' + inspect(name));
return this;
};
Assertion.prototype.length()
Assert that object has expected length.
expect([1,2,3]).to.have.length(3);
expect('foobar').to.have.length(6);
View Source
Assertion.prototype.length = function (n) {
new Assertion(this.obj).to.have.property('length');
var len = this.obj.length;
this.assert(
len == n
, 'expected ' + this.inspect + ' to have a length of ' + n + ' but got ' + len
, 'expected ' + this.inspect + ' to not have a length of ' + len);
return this;
};
Assertion.prototype.match()
Assert that matches regular expression.
expect('foobar').to.match(/^foo/);
View Source
Assertion.prototype.match = function (re) {
this.assert(
re.exec(this.obj)
, 'expected ' + this.inspect + ' to match ' + re
, 'expected ' + this.inspect + ' not to match ' + re);
return this;
};
Assertion.prototype.contain()
Assert the inclusion of an object in an Array
expect([1,2,3]).to.contain(2);
View Source
Assertion.prototype.contain = function (obj) {
new Assertion(this.obj).to.be.an.instanceof(Array);
this.assert(
~this.obj.indexOf(obj)
, 'expected ' + this.inspect + ' to contain ' + inspect(obj)
, 'expected ' + this.inspect + ' to not contain ' + inspect(obj));
return this;
};
Assertion.prototype.string()
Assert inclusion of string in string.
expect('foobar').to.include.string('bar');
View Source
Assertion.prototype.string = function (str) {
new Assertion(this.obj).is.a('string');
this.assert(
~this.obj.indexOf(str)
, 'expected ' + this.inspect + ' to include ' + inspect(str)
, 'expected ' + this.inspect + ' to not include ' + inspect(str));
return this;
};
Assertion.prototype.object()
Assert inclusion of object in object.
var obj = {foo: 'bar', baz: {baaz: 42}, qux: 13};
expect(obj).to.include.object({foo: 'bar'});
View Source
Assertion.prototype.object = function(obj){
new Assertion(this.obj).is.a('object');
var included = true;
for (var key in obj) {
if (obj.hasOwnProperty(key) && !eql(obj[key], this.obj[key])) {
included = false;
break;
}
}
this.assert(
included
, 'expected ' + this.inspect + ' to include ' + inspect(obj)
, 'expected ' + this.inspect + ' to not include ' + inspect(obj));
return this;
}
Language chain that lags #keys to test for inclusion testing.
View Source
Assertion.prototype.__defineGetter__('include', function () {
this.includes = true;
return this;
});
Assertion.prototype.keys()
Assert exact keys or the inclusing of keys using
the include modifier.
expect({ foo: 1, bar: 2 }).to.have.keys(['foo', 'bar']);
expect({ foo: 1, bar: 2, baz: 3 }).to.include.keys('foo', 'bar');
View Source
Assertion.prototype.keys = function(keys) {
var str
, ok = true;
keys = keys instanceof Array
? keys
: Array.prototype.slice.call(arguments);
if (!keys.length) throw new Error('keys required');
var actual = Object.keys(this.obj)
, len = keys.length;
// Inclusion
ok = keys.every(function(key){
return ~actual.indexOf(key);
});
// Strict
if (!this.negate && !this.includes) {
ok = ok && keys.length == actual.length;
}
// Key string
if (len > 1) {
keys = keys.map(function(key){
return inspect(key);
});
var last = keys.pop();
str = keys.join(', ') + ', and ' + last;
} else {
str = inspect(keys[0]);
}
// Form
str = (len > 1 ? 'keys ' : 'key ') + str;
// Have / include
str = (this.includes ? 'include ' : 'have ') + str;
// Assertion
this.assert(
ok
, 'expected ' + this.inspect + ' to ' + str
, 'expected ' + this.inspect + ' to not ' + str);
return this;
}
Assertion.prototype.throw()
Assert that a function will throw a specific
type of error.
var fn = function () { throw new ReferenceError(''); }
expect(fn).to.throw(ReferenceError);
View Source
Assertion.prototype.throw = function (constructor) {
new Assertion(this.obj).is.a('function');
constructor = constructor || Error;
var name = constructor.name
, thrown = false;
try {
this.obj();
} catch (err) {
thrown = true;
this.assert(
err instanceof constructor
, 'expected ' + this.inspect + ' to throw ' + name
, 'expected ' + this.inspect + ' to not throw ' + name);
return this;
}
this.assert(
thrown === true
, 'expected ' + this.inspect + ' to throw ' + name
, 'expected ' + this.inspect + ' to not throw ' + name);
};