deepEqual may ignore object's null/undefined properties, by configuration

I think it would be nice to have a chai configuration property to set chai to ignore null or undefined properties on object deepEqual assertion (e.g. chai.config.ignoreNullOrUndefinedProperties = true).

    var objA = {
        foo: 'bar',
        not_relevant: undefined,
        not_serializable: null
    };

    expect(objA).to.eql({foo: 'bar'});
    // false

    expect(JSON.pase(JSON.stringify(objA)).to.eql({foo: 'bar'}));
    // true

This is useful for instance when we want to filter objects’s properties before serialization (e.g REST APIs). These objects may have optional properties set to undefined which won’t be serialized. Example:

  var pick = require('mout/object/pick');
  var USER_FILTER = ['login','company'];

  function filterUser(user) {
    if(!user) return;

    return {
      login: user.login,
      company: user.company,
    };
    // same as: return pick(user, USER_FILTER);
  };

  var usersBD = {
    bob: {
      login: 'bob',
      lastLoggin: '2014-12-27T00:00:00+00:00',
      password: 'some_hash',
    },
    alice: {
      login: 'alice',
      lastLoggin: '2014-12-27T00:00:00+00:00',
      password: 'some_hash',
      company: 'Wonderland'
    }
  };

  //
  //
  expect(filterUser(usersBD['bob'])).to.eql({login: 'bob'});
  // will fail because filterUser(usersBD['bob']) returns
  // {login: 'bob', company: 'udefined'}
  // but since the object will be  serialized to JSON
  // does not matter

  expect(filterUser(usersBD['alice'])).to.eql({
    login: 'alice',
    company: 'Wonderland'
  }); // success

For this simple case scenario, I cloud do something like:

function filterUser(user) {
  if (!user) return;

  var filteredUser = {
    login: user.login
  };

  if (user.company) {
    filteredUser.company = user.company;
  }

  return filteredUser;
};

But sometimes we have several optional properties which will require more verbose code polluted with if statements.

Currently I overcome this with JSON.stringify.

Is this a good feature, does it meet chai purpose?

[evtaranov]

+1 I have a similar case to test, where i need to ignore undefined values, because after JSON.parse(JSON.toString(…)) they are lost and deepEqual() return false.

[keithamus]

Sure @ronjouch! Specifically https://github.com/chaijs/chai/projects/2#card-10444381 and https://github.com/chaijs/chai/projects/2#card-10444260 capture the desired functionality. This is a matcher API which would allow you to pass expectations as properties in a deep-eql assertion, e.g.

expect({ a: 1, b: 2, c: 3 }).to.deep.eql({ a: 1, b: 2, c: expect.to.be.a('number')  }); 

or in the case of the OPs example for a users table you could do something like:

  expect(usersBD['alice']).to.eql({
    login: 'alice',
    password: expect.to.be.a('string').with.lengthOf(40),
    lastLogin: expect.to.be.a('string'),
    company: 'Wonderland'
  }); // success

If you’re looking for an assertion which only tests the existance of some keys, we already have this available. But we think having a matcher API to make more broad assertions on object properties is the right direction here.