CODEWITHSUNDEEP
javascriptarraysobjecttddchai
user1082754
user1082754

Reputation:

Chai.js: Object contains/includes

Chai has an include method. I want to test to see if an object contains another object. For example:

var origin = {
  name: "John",
  otherObj: {
    title: "Example"
  }
}

I want to use Chai to test if this object contains the following (which it does)

var match = {
  otherObj: {
    title: "Example"
  }
}

Doing this does not appear to work:

origin.should.include(match)

Upvotes: 25

Views: 42421

Answers (5)

Sebastien Horin
Sebastien Horin

Reputation: 11067

If you know the level of the subobject you can simply use:

expect(origin.otherObj).to.include(match.otherObj);

https://www.chaijs.com/api/bdd/

Upvotes: 6

eagleeye
eagleeye

Reputation: 438

Hei, just published chai-subset. Check this out: https://www.npmjs.org/package/chai-subset This should work for you)

 var chai = require('chai');
 var chaiSubset = require('chai-subset');
 chai.use(chaiSubset);

 var obj = {
     a: 'b',
     c: 'd',
     e: {
         foo: 'bar',
         baz: {
             qux: 'quux'
         }
     }
 };

 expect(obj).to.containSubset({
     e: {
         foo: 'bar',
         baz: {
             qux: 'quux'
         }
     }
 });

Upvotes: 34

jc1
jc1

Reputation: 621

In chai 4.2.0, for example you can use deep include

chaijs doc examples:

// Target array deeply (but not strictly) includes `{a: 1}`
expect([{a: 1}]).to.deep.include({a: 1});
expect([{a: 1}]).to.not.include({a: 1});

// Target object deeply (but not strictly) includes `x: {a: 1}`
expect({x: {a: 1}}).to.deep.include({x: {a: 1}});
expect({x: {a: 1}}).to.not.include({x: {a: 1}});

Upvotes: 12

Frances McMullin
Frances McMullin

Reputation: 5706

The include and contain assertions can be used as either property based language chains or as methods to assert the inclusion of an object in an array or a substring in a string. When used as language chains, they toggle the contain flag for the keys assertion. [emphasis mine]

So if you're invoking include on an object (not an array or a string), then it only serves to toggle the contain flag for the keys assertion. By the looks of your example, testing for deep equality would make more sense, possibly checking for the key first.

origins.should.include.keys("otherObj");
origins.otherObj.should.deep.equal(match.otherObj);

Actually, now I browse the other examples, you would probably be happiest with this :

origins.should.have.deep.property("otherObj", match.otherObj)

Upvotes: 19

machnicki
machnicki

Reputation: 531

In Chai 1.5.0 you will find handy method 

includeDeepMembers

http://chaijs.com/releases/

Upvotes: -4

Related Questions