(Better) Chai Shallow Deep Equal plugin

This module provides a drop-in replacement shallowDeepEqual assertion for chai that uses strict semantics and an intuitive output diff.

Under the hood the library wraps the Unexpected library, specifically making use of the structural "to satisfy" assertion.

Use

Once installed the plugin can be simply imported and used as a plugin:

const chai = require("chai");
const expect = chai.expect;

chai.use(require("chai-better-shallow-deep-equal"));

An additional .shallowDeepEqual() assertion is then available for use and on error an informative diff will be printed:

expect({ foo: true, bar: 0 }).to.shallowDeepEqual({ foo: true, bar: 1 });

expected { foo: true, bar: 0 } to satisfy { foo: true, bar: 1 }

{
  foo: true,
  bar: 0 // should equal 1
}

The assertion works with all three chai APIs: expect, should and assert.

Support for ES6 types

The plugin has support for structurally comparing both Map and Set objects:

expect(
  new Map([
    ["foo", 1],
    ["bar", false]
  ])
).to.shallowDeepEqual(
  new Map([
    ["foo", 1],
    ["bar", true]
  ])
);

expected new Map[ ['foo', 1], ['bar', false] ])
to satisfy new Map[ ['foo', 1], ['bar', true] ])

new Map[
  ['foo', 1,]
  ['bar',
    false // should equal true
  ]
])

expect(new Set(["foo", "baz"])).to.shallowDeepEqual(
  new Set(["foo", "bar"])
);

expected new Set([ 'foo', 'baz' ]) to satisfy new Set([ 'foo', 'bar' ])

new Set([
  'foo',
  'baz' // should be removed
  // missing 'bar'
])

Customisation

Adding types

Sometimes it can be beneficial to identify certain types within the test suite - perhaps to customise their display or to treat them otherwise differently. This can be achieved by using the addType() API:

const chaiBetterShallowDeepEqual = require("chai-better-shallow-deep-equal");

chaiBetterShallowDeepEqual.addType({
  name: "CustomDate",
  base: "date",
  identify: obj => obj && obj._isCustomDate
});

In the example above, we are trying to single out certain objects that occur within a hypthetical test suite that use custom dates by checking whether they have an "isCustomDate" property.

Given our definition of the identify() method above, when the plugin encounters such objects it will think of them as CustomDate and be aware that they extend the behavior of the builtin date type.

This API accepts the same options as the Unexpected addType() method. Please consult the link for more detailed description.

Custom Matching

With the availablity of custom types are in the picture, one common desire is to allow customising the way those identified types are matched.

By default only alike types are compared, but suppose that within our tests we want to allow comparing any CustomDate object against a, ISO time string.

Let's stick with the exmaple from our earlier hypothetical - we can define allowing the comparison using the addMatch() API:

chaiBetterShallowDeepEqual.addMatch({
  leftType: "CustomDate",
  rightType: "string",
  handler: (lhs, rhs) => [lhs.toISOString(), rhs]
});

What we've defined here is when we see a CustomDate being compared to a string, to instead first convert it to an ISO string and then do the comparison. In the test suite, the effect is to allow expecations to be defined in a way that is much more easily read:

const fooDate = new Date(1583947016326);

expect({ fooDate }).to.shallowDeepEqual({
  fooDate: "2020-03-11T17:16:56.326Z"
});

expected { fooDate: new Date('2020-03-11T17:16:56.326Z') }
to satisfy { fooDate: '2020-03-11T17:16:56.326Z' }

{
  fooDate: new Date('2020-03-11T17:16:56.326Z') // should equal '2020-03-11T17:16:56.326Z'
}