# chai-fuzzy
Fuzzy matchers for chai based on underscore and inspired by jasmine.
Make assertions that values have all the same attributes and values without asserting strict object equality.
[](https://travis-ci.org/elliotf/chai-fuzzy)
## Using
Also see the [tests](https://github.com/elliotf/chai-fuzzy/tree/master/test/) and [examples](https://github.com/elliotf/chai-fuzzy/tree/master/examples/).
### browser-side
include chai fuzzy after chai and underscore:
<script src="underscore.js"></script>
<script src="chai.js"></script>
<script src="chai-fuzzy.js"></script>
### server-side
have chai use chai-fuzzy:
var chai = require('chai');
chai.use(require('chai-fuzzy'));
## Assertions
### like(value)
compare object attributes and values rather than checking to see if they're the same reference
var subject = {a: 'a'};
subject.should.be.like({a: 'a'});
subject.should.not.be.like({x: 'x'});
subject.should.not.be.like({a: 'a', b: 'b'});
expect(subject).to.be.like({a: 'a'});
expect(subject).not.to.be.like({x: 'x'});
expect(subject).not.to.be.like({a: 'a', b: 'b'});
assert.like(subject, {a: 'a'});
assert.notLike(subject, {x: 'x'});
assert.notLike(subject, {a: 'a', b: 'b'});
var subject = ['a'];
subject.should.be.like(['a']);
subject.should.not.be.like(['x']);
subject.should.not.be.like(['a', 'b']);
expect(subject).to.be.like(['a']);
expect(subject).not.to.be.like(['x']);
expect(subject).not.to.be.like(['a', 'b']);
assert.like(subject, ['a']);
assert.notLike(subject, ['x']);
assert.notLike(subject, ['a', 'b']);
## containOneLike(value)
check the first level of the container for a value like the one provided
var subject = {
a: 'alphabet'
, b: 'butternut'
, c: {
name: 'chowder'
, attributes: [
'scales'
, 'fins'
]
}
, x: 'xylophone'
, z: 'xylophone'
};
subject.should.containOneLike({
name: 'chowder'
, attributes: [
'scales', 'fins'
]
});
subject.should.not.containOneLike({
name: 'chowder'
, attributes: [
'scales', 'fins', 'cream'
]
});
subject.should.containOneLike('xylophone');
subject.should.not.containOneLike('cow patties');
expect(subject).to.containOneLike('xylophone');
expect(subject).to.not.containOneLike('cow patties');
assert.containOneLike(subject, 'xylophone');
assert.notContainOneLike(subject, 'cow patties');
// same for arrays
# jsonOf(value)
check that the given javascript object is like the JSON-ified expected value. Useful for checking stringification and parsing of an object.
var apple = {
skin: 'thin'
, colors: ['red', 'green', 'yellow']
, isFruit: true
, picked: new Date()
};
var orange = {
skin: 'thin'
, colors: ['red', 'green', 'yellow']
, isFruit: true
, picked: new Date()
};
// here appleJSON would be the json result of some process like a JSON api
var appleJSON = JSON.parse(JSON.stringify(apple));
appleJSON.should.be.jsonOf(apple);
appleJSON.should.not.be.jsonOf(orange);
expect(appleJSON).to.be.jsonOf(apple);
expect(appleJSON).to.not.be.jsonOf(orange);
assert.jsonOf(appleJSON, apple);
assert.notJsonOf(appleJSON, orange);
# Thanks
Thanks to [Davis](http://github.com/infews/ "Davis") for passing along the idea of using underscore rather than cribbing parts of jasmine.
Thanks to [Bart van der Schoor](https://github.com/Bartvds "Bart van der Schoor") for adding assert-style compatibility