Skip to content
fuzzy matchers for chai, based on underscore
Branch: master
Clone or download
Pull request Compare This branch is 6 commits behind elliotf:master.
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
examples
test
.gitignore
.travis.yml
LICENSE
Makefile
README.md
chai-fuzzy.js
index.js
package.json

README.md

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.

Build Status

Using

Also see the tests and 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 for passing along the idea of using underscore rather than cribbing parts of jasmine.

Thanks to Bart van der Schoor for adding assert-style compatibility

You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.