详解Chai.js断⾔库API中⽂⽂档
Chai.js断⾔库API中⽂⽂档
基于chai.js官⽅API⽂档翻译。仅列出BDD风格的expect/should API。TDD风格的Assert API由于不打算使⽤，暂时不放，后续可能会更新。
BDD
expect和should是BDD风格的，⼆者使⽤相同的链式语⾔来组织断⾔，但不同在于他们初始化断⾔的⽅式：expect使⽤构造函数来创建断⾔对象实例，⽽should通过为Object.prototype新增⽅法来实现断⾔（所以should不⽀持IE）；expect直接指向pect，⽽should则是chai.should()。
个⼈⽐较建议使⽤expect，should不仅不兼容IE，在某些情况下还需要改变断⾔⽅式来填坑。详细的⽐较可以看看官⽹，说的很清楚。
var chai = require('chai') ,
expect = pect ,
should = chai.should()
语⾔链
下⾯的接⼝是单纯作为语⾔链提供以期提⾼断⾔的可读性。除⾮被插件改写否则它们⼀般不提供测试功能。
1. to
2. be
3. been
4. is
5. that
6. which
7. and
8. has
9. have
10. with
11. at
12. of
13. same
.not
对之后的断⾔取反
expect(foo).to.not.equal('bar')
expect(goodFn).to.not.throw(Error)
expect({ foo: 'baz'}).to.have.property('foo')
.qual('bar')
.deep
设置deep标记，然后使⽤equal和property断⾔。该标记可以让其后的断⾔不是⽐较对象本⾝，⽽是递归⽐较对象的键值对
expect(foo).to.deep.equal({ bar: 'baz'})
expect({ foo: { bar: { baz: 'quux'}}})
.to.have.deep.property('foo.bar.baz', 'quux')
deep.property中的特殊符号可以使⽤双反斜杠进⾏转义（第⼀个反斜杠是在字符串参数中对第⼆个反斜杠进⾏转义，第⼆个反斜杠⽤于在property中进⾏转义）
var deepCss = { '.link': { '[target]': 42 } }
expect(deepCss).to.have.deep.property('\\.link.\\[target\\]', 42)
.any
在keys断⾔之前使⽤any标记（与all相反）
expect(foo).to.have.any.keys('bar', 'baz')
.all
在keys断⾔之前使⽤all标记（与any相反）
expect(foo).to.have.all.keys('bar', 'baz')
.a(type) / .an(type)
type：String，被测试的值的类型
a和an断⾔即可作为语⾔链⼜可作为断⾔使⽤
// 类型断⾔
expect('test').to.be.a('string');
expect({ foo: 'bar' }).to.be.an('object');
expect(null).to.be.a('null');
expect(undefined).to.be.an('undefined');
expect(new Error).to.be.an('error');
expect(new Promise).to.be.a('promise');
expect(new Float32Array()).to.be.a('float32array');
expect(Symbol()).to.be.a('symbol');
// es6 overrides
expect({[StringTag]:()=>'foo'}).to.be.a('foo');
// language chain
expect(foo).to.be.an.instanceof(Foo);
.include(value) / contains(value)
value：Object | String | Number
include()和contains()即可作为属性类断⾔前缀语⾔链⼜可作为作为判断数组、字符串是否包含某值的断⾔使⽤。当作为语⾔链使⽤时，常⽤于key()断⾔之前
expect([1, 2, 3]).to.include(2)
expect('foobar').to.include('bar')
expect({ foo: 'bar', hello: 'universe' }).to.include.keys('foo')
.ok
断⾔⽬标为真值。
expect('everything').to.be.ok
expect(1).to.be.ok
expect(false).to.not.be.ok
expect(null).to.not.be.ok
.true
断⾔⽬标为true，注意，这⾥与ok的区别是不进⾏类型转换，只能为true才能通过断⾔
expect(true).ue
expect(be.true
.false
断⾔⽬标为false
expect(false).to.be.false
expect(0).to.not.be.false
.null
断⾔⽬标为null
expect(null).to.be.null
expect(undefined).to.not.be.null
.undefined
断⾔⽬标为undefined。
expect(undefine).to.be.undefined
expect(null).to.not.be.undefined
.NaN
断⾔⽬标为⾮数字NaN
expect('foo').to.be.null
expect(be.null
.exist
断⾔⽬标存在，即⾮null也⾮undefined
var foo = 'hi',
bar = null,
baz
expect(foo).to.exist
expect(bar).ist
expect(baz).ist
.empty
断⾔⽬标的长度为0。对于数组和字符串，它检查length属性，对于对象，它检查可枚举属性的数量expect([]).pty
expect('').pty
expect({}).pty
.arguments
断⾔⽬标是⼀个参数对象arguments
function test () {
expect(arguments).to.be.arguments
}
.equal(value)
value：Mixed
断⾔⽬标严格等于(===)value。另外，如果设置了deep标记，则断⾔⽬标深度等于value
expect('hello').to.equal('hello')
expect(42).to.equal(42)
expect(1).to.not.equal(true)
expect({ foo: 'bar'}).to.not.equal({ foo: 'bar'})
expect({ foo: 'bar'}).to.deep.equal({foo: 'bar'})
.eql(value)
js中文正则表达式value：Mixed
断⾔⽬标深度等于value，相当于deep.equal(value)的简写
expect({ foo: 'bar' }).to.eql({ foo: 'bar' })
expect([1, 2, 3]).to.eql([1, 2, 3])
.above(value)
value： Number
断⾔⽬标⼤于（超过）value
expect(10).to.be.above(5)
也可接在length后来断⾔⼀个最⼩的长度。相⽐直接提供长度的好处是提供了更详细的错误消息expect('foo').to.have.length.above(2)
expect([1, 2, 3]).to.have.length.above(2)
.least(value)
value： Number
断⾔⽬标不⼩于（⼤于或等于）value
expect(10).to.be.at.least(10)
也可接在length后来断⾔⼀个最⼩的长度。相⽐直接提供长度的好处是提供了更详细的错误消息
expect('foo').to.have.length.of.at.least(3)
expect([1, 2, 3]).to.have.length.of.at.least(3)
.below(value)
value：Number
断⾔⽬标⼩于value
expect(5).to.be.below(10)
也可接在length后来断⾔⼀个最⼤的长度。相⽐直接提供长度的好处是提供了更详细的错误消息
expect('foo').to.have.length.below(4)
expect([1, 2, 3]).to.have.length.below(4)
.most(value)
value：String
断⾔⽬标不⼤于（⼩于或等于）value
expect(5).to.st(5)
也可接在length后来断⾔⼀个最⼤的长度。相⽐直接提供长度的好处是提供了更详细的错误消息
expect('foo').to.have.length.st(4)
expect([1, 2, 3]).to.have.length.st(3)
.within(start, finish)
start：Number，下限
finish：Number，上限
断⾔⽬标在某个区间内
expect(7).to.be.within(5, 10)
也可接在length后来断⾔⼀个长度区间。相⽐直接提供长度的好处是提供了更详细的错误消息
expect('foo').to.have.length.within(2, 4)
expect([1, 2, 3]).to.have.length.within(2, 4)
.instanceof(constructor)
constructor：Constructor，构造函数
断⾔⽬标是构造函数constructor的⼀个实例
var Tea = function (name) { this.name = name },
Chai = new Tea('chai')
expect(Chai).to.be.an.instanceof(Tea)
expect([1, 2, 3]).to.be.an.instanceof(Array)
.property(name, [value])
name：String，属性名
value：Mixed，可选，属性值
断⾔⽬标是否拥有某个名为name的属性，可选地如果提供了value则该属性值还需要严格等于（===）value。如果设置了deep标记，则可以使⽤点.和中括号[]来指向对象和数组中的深层属性
// 简单引⽤
var obj = { foo: 'bar' }
expect(obj).to.have.property('foo')
expect(pbj).to.have.property('foo', 'bar')
// 深层引⽤
var deepObj = {
green: { tea: 'matcha' },
teas: [ 'Chai', 'matcha', { tea: 'konacha' } ]
}
expect(deepObj).to.have.deep.property('a', 'matcha')
expect(deepObj).to.have.deep.property('teas[1]', 'matcha')
expect(deepObj).to.have.deep.property('teas[2].tea', 'konacha')
如果⽬标是⼀个数组，还可以直接使⽤⼀个或多个数组下标作为name来在嵌套数组中断⾔deep.property
var arr = [
[ 'chai', 'matcha', 'konacha' ],
[ { tea: 'chai' },
{ tea: 'matcha' },
{ tea: 'konacha' }
]
]
expect(arr).to.have.deep.property('[0][1]', 'matcha')
expect(arr).to.have.deep.property('[1][2].tea', 'konacha')
此外，property把断⾔的主语（subject）从原来的对象变为当前属性的值，使得可以在其后进⼀步衔接其它链式断⾔（来针对这个属性值进⾏测试）
expect(obj).to.have.property('foo')
.that.is.a('string')
expect(deepObj).to.have.property('green')
.that.is.an('object')
.that.deep.equals({ tea: 'matcha' })
expect(deepObj).to.have.property('teas')
.that.is.an('array')
.with.deep.property('[2]')
.that.deep.equals({ tea: 'konacha' })
注意，只有当设置了deep标记的时候，在property() name中的点（.）和中括号（[]）才必须使⽤双反斜杠\进⾏转义（为什么是双反斜杠，在前⽂有提及），当没有设置deep标记的时候，是不能进⾏转义的
// 简单指向
var css = { '.link[target]': 42 }
expect(css).to.have.property('.link[target]', 42)
//深度指向
var deepCss = { 'link': { '[target]': 42 } }
expect(deepCss).to.have.deep.property('\\.link\\.[target]', 42)
.ownProperty(name)
name：String，属性名
断⾔⽬标拥有名为name的⾃有属性
expect('test').to.have.ownProperty('length')
.ownPropertyDescription(name[, descriptor])
1. name：String，属性名
2. descriptor： Object，描述对象，可选
断⾔⽬标的某个⾃有属性存在描述符对象，如果给定了descroptor描述符对象，则该属性的描述符对象必须与其相匹配
expect('test').to.have.ownPropertyDescriptor('length')
expect('test').to.have.ownPropertyDescriptor('length', {
enumerable: false,
configrable: false,
writeable: false,
value: 4
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论