chai-exclude

What is chai-exclude?

The chai-exclude npm package is a plugin for the Chai assertion library that allows you to exclude specific keys from objects when performing deep equality checks. This is particularly useful when you want to ignore certain properties that may vary or are not relevant to the test.

What are chai-exclude's main functionalities?

Exclude specific keys from deep equality checks

This feature allows you to exclude specific keys from deep equality checks. In the example, the key 'c' is excluded from the comparison, so the objects are considered equal even though their 'c' values differ.

const chai = require('chai');
const chaiExclude = require('chai-exclude');
chai.use(chaiExclude);
const expect = chai.expect;

const obj1 = { a: 1, b: 2, c: 3 };
const obj2 = { a: 1, b: 2, c: 4 };

expect(obj1).excluding('c').to.deep.equal(obj2);

Exclude multiple keys from deep equality checks

This feature allows you to exclude multiple keys from deep equality checks. In the example, the keys 'c' and 'd' are excluded from the comparison, so the objects are considered equal even though their 'c' and 'd' values differ.

const chai = require('chai');
const chaiExclude = require('chai-exclude');
chai.use(chaiExclude);
const expect = chai.expect;

const obj1 = { a: 1, b: 2, c: 3, d: 4 };
const obj2 = { a: 1, b: 2, c: 5, d: 6 };

expect(obj1).excluding(['c', 'd']).to.deep.equal(obj2);

Exclude nested keys from deep equality checks

This feature allows you to exclude nested keys from deep equality checks. In the example, the nested key 'b.y' is excluded from the comparison, so the objects are considered equal even though their 'b.y' values differ.

const chai = require('chai');
const chaiExclude = require('chai-exclude');
chai.use(chaiExclude);
const expect = chai.expect;

const obj1 = { a: 1, b: { x: 2, y: 3 } };
const obj2 = { a: 1, b: { x: 2, y: 4 } };

expect(obj1).excluding('b.y').to.deep.equal(obj2);

Other packages similar to chai-exclude

deep-equal

The deep-equal package provides deep equality comparison for Node.js and browsers. It does not offer the ability to exclude specific keys from the comparison, making chai-exclude more flexible for tests where certain properties should be ignored.

lodash.isequal

Lodash's isEqual function performs a deep comparison between two values to determine if they are equivalent. While powerful, it does not natively support excluding specific keys from the comparison, which is a feature provided by chai-exclude.

README

chai-exclude

Exclude keys before a deep equal operation with chaijs expect.

Why?

Sometimes you'll need to exclude object properties that generate unique values while doing a deep equal comparison. This plugin makes it easier to remove those top level properties before comparison.

https://github.com/chaijs/chai/issues/885

Installation

npm install chai-exclude --only=dev

yarn add chai-exclude --dev

Usage

Require

const chai = require('chai');
const chaiExclude = require('chai-exclude');

chai.use(chaiExclude);

ES6 Import

import { use } from 'chai';
import chaiExclude from 'chai-exclude';

use(chaiExclude);

TypeScript

import { use } from 'chai';
import chaiExclude = require('chai-exclude');

use(chaiExclude);

// The typings for chai-exclude are included with the package itself.

Example

a) excluding

1. Excluding a property from an object

expect({ a: 'a', b: 'b' }).excluding('a').to.deep.equal({ b: 'b' })

1. Excluding multiple top level properties from an object

const obj = {
  a: 'a',
  b: 'b',
  c: {
    d: 'd',
    e: 'e'
  }
}

expect(obj).excluding(['a', 'c']).to.deep.equal({ b: 'b' })

b) excludingEvery

1. Excluding every property in a deeply nested object

const actual = {
  a: 'a',
  b: 'b',
  c: {
    a: 'a',
    b: {
      a: 'a',
      d: {
        a: 'a',
        b: 'b',
        d: null
      }
    }
  },
  d: ['a', 'c']
}

const expected = {
  b: 'b',
  c: {
    b: {
      d: {
        b: 'b',
        d: null
      }
    }
  },
  d: ['a', 'c']
}

expect(actual).excludingEvery('a').to.deep.equal(expected)

1. Excluding multiple properties in a deeply nested object

const actual = {
  a: 'a',
  b: 'b',
  c: {
    a: 'a',
    b: {
      a: 'a',
      d: {
        a: 'a',
        b: 'b',
        d: null
      }
    }
  },
  d: ['a', 'c']
}

const expected = {
  b: 'b',
  c: {
    b: {
      d: {      // d is not removed because it is an object
        b: 'b'
      }
    }
  }
}

expect(actual).excludingEvery(['a', 'd']).to.deep.equal(expected)

Note: excludingEvery will not remove the property if it is an object in a deeply nested object.

Contributing

Contributions are welcome. If you have any questions create an issue here.

License

MIT