chai-fuzzy

fuzzy matchers for chai

Downloads in past

Stats

StarsIssuesVersionUpdatedCreatedSize
chai-fuzzy
2541.6.17 years ago10 years agoMinified + gzip package size for chai-fuzzy in KB

Readme

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