tests.js

(function (root, factory) {
  if (typeof define === 'function' && define.amd) { // eslint-disable-line no-undef
    define(['deep-diff', 'expect.js'], factory);// eslint-disable-line no-undef
  } else if (typeof module === 'object' && module.exports) {
    module.exports = factory(require('../'), require('expect.js'));
  } else {
    root.returnExports = factory(root.DeepDiff, root.expect);
  }
  // eslint-disable-next-line no-undef
}(typeof self !== 'undefined' ? self : this, function (deep, expect) {

  describe('deep-diff', function () {
    var empty = {};

    describe('A target that has no properties', function () {

      it('shows no differences when compared to another empty object', function () {
        expect(deep.diff(empty, {})).to.be.an('undefined');
      });

      describe('when compared to a different type of keyless object', function () {
        var comparandTuples = [
          ['an array', {
            key: []
          }],
          ['an object', {
            key: {}
          }],
          ['a date', {
            key: new Date()
          }],
          ['a null', {
            key: null
          }],
          ['a regexp literal', {
            key: /a/
          }],
          ['Math', {
            key: Math
          }]
        ];

        comparandTuples.forEach(function (lhsTuple) {
          comparandTuples.forEach(function (rhsTuple) {
            if (lhsTuple[0] === rhsTuple[0]) {
              return;
            }
            it('shows differences when comparing ' + lhsTuple[0] + ' to ' + rhsTuple[0], function () {
              var diff = deep.diff(lhsTuple[1], rhsTuple[1]);
              expect(diff).to.be.ok();
              expect(diff.length).to.be(1);
              expect(diff[0]).to.have.property('kind');
              expect(diff[0].kind).to.be('E');
            });
          });
        });
      });

      describe('when compared with an object having other properties', function () {
        var comparand = {
          other: 'property',
          another: 13.13
        };
        var diff = deep.diff(empty, comparand);

        it('the differences are reported', function () {
          expect(diff).to.be.ok();
          expect(diff.length).to.be(2);

          expect(diff[0]).to.have.property('kind');
          expect(diff[0].kind).to.be('N');
          expect(diff[0]).to.have.property('path');
          expect(diff[0].path).to.be.an(Array);
          expect(diff[0].path[0]).to.eql('other');
          expect(diff[0]).to.have.property('rhs');
          expect(diff[0].rhs).to.be('property');

          expect(diff[1]).to.have.property('kind');
          expect(diff[1].kind).to.be('N');
          expect(diff[1]).to.have.property('path');
          expect(diff[1].path).to.be.an(Array);
          expect(diff[1].path[0]).to.eql('another');
          expect(diff[1]).to.have.property('rhs');
          expect(diff[1].rhs).to.be(13.13);
        });

      });

    });

    describe('A target that has one property', function () {
      var lhs = {
        one: 'property'
      };

      it('shows no differences when compared to itself', function () {
        expect(deep.diff(lhs, lhs)).to.be.an('undefined');
      });

      it('shows the property as removed when compared to an empty object', function () {
        var diff = deep.diff(lhs, empty);
        expect(diff).to.be.ok();
        expect(diff.length).to.be(1);
        expect(diff[0]).to.have.property('kind');
        expect(diff[0].kind).to.be('D');
      });

      it('shows the property as edited when compared to an object with null', function () {
        var diff = deep.diff(lhs, {
          one: null
        });
        expect(diff).to.be.ok();
        expect(diff.length).to.be(1);
        expect(diff[0]).to.have.property('kind');
        expect(diff[0].kind).to.be('E');
      });

      it('shows the property as edited when compared to an array', function () {
        var diff = deep.diff(lhs, ['one']);
        expect(diff).to.be.ok();
        expect(diff.length).to.be(1);
        expect(diff[0]).to.have.property('kind');
        expect(diff[0].kind).to.be('E');
      });

    });

    describe('A target that has null value', function () {
      var lhs = {
        key: null
      };

      it('shows no differences when compared to itself', function () {
        expect(deep.diff(lhs, lhs)).to.be.an('undefined');
      });

      it('shows the property as removed when compared to an empty object', function () {
        var diff = deep.diff(lhs, empty);
        expect(diff).to.be.ok();
        expect(diff.length).to.be(1);
        expect(diff[0]).to.have.property('kind');
        expect(diff[0].kind).to.be('D');
      });

      it('shows the property is changed when compared to an object that has value', function () {
        var diff = deep.diff(lhs, {
          key: 'value'
        });
        expect(diff).to.be.ok();
        expect(diff.length).to.be(1);
        expect(diff[0]).to.have.property('kind');
        expect(diff[0].kind).to.be('E');
      });

      it('shows that an object property is changed when it is set to null', function () {
        lhs.key = {
          nested: 'value'
        };
        var diff = deep.diff(lhs, {
          key: null
        });
        expect(diff).to.be.ok();
        expect(diff.length).to.be(1);
        expect(diff[0]).to.have.property('kind');
        expect(diff[0].kind).to.be('E');
      });

    });


    describe('A target that has a date value', function () {
      var lhs = {
        key: new Date(555555555555)
      };

      it('shows the property is changed with a new date value', function () {
        var diff = deep.diff(lhs, {
          key: new Date(777777777777)
        });
        expect(diff).to.be.ok();
        expect(diff.length).to.be(1);
        expect(diff[0]).to.have.property('kind');
        expect(diff[0].kind).to.be('E');
      });

    });


    describe('A target that has a NaN', function () {
      var lhs = {
        key: NaN
      };

      it('shows the property is changed when compared to another number', function () {
        var diff = deep.diff(lhs, {
          key: 0
        });
        expect(diff).to.be.ok();
        expect(diff.length).to.be(1);
        expect(diff[0]).to.have.property('kind');
        expect(diff[0].kind).to.be('E');
      });

      it('shows no differences when compared to another NaN', function () {
        var diff = deep.diff(lhs, {
          key: NaN
        });
        expect(diff).to.be.an('undefined');
      });

    });


    describe('can revert namespace using noConflict', function () {
      if (deep.noConflict) {
        deep = deep.noConflict();

        it('conflict is restored (when applicable)', function () {
          // In node there is no global conflict.
          if (typeof globalConflict !== 'undefined') {
            expect(DeepDiff).to.be(deep); // eslint-disable-line no-undef
          }
        });

        it('DeepDiff functionality available through result of noConflict()', function () {
          expect(deep.applyDiff).to.be.a('function');
        });
      }
    });


    describe('When filtering keys', function () {
      var lhs = {
        enhancement: 'Filter/Ignore Keys?',
        numero: 11,
        submittedBy: 'ericclemmons',
        supportedBy: ['ericclemmons'],
        status: 'open'
      };
      var rhs = {
        enhancement: 'Filter/Ignore Keys?',
        numero: 11,
        submittedBy: 'ericclemmons',
        supportedBy: [
          'ericclemmons',
          'TylerGarlick',
          'flitbit',
          'ergdev'
        ],
        status: 'closed',
        fixedBy: 'flitbit'
      };

      describe('if the filtered property is an array', function () {

        it('changes to the array do not appear as a difference', function () {
          var prefilter = function (path, key) {
            return key === 'supportedBy';
          };
          var diff = deep(lhs, rhs, prefilter);
          expect(diff).to.be.ok();
          expect(diff.length).to.be(2);
          expect(diff[0]).to.have.property('kind');
          expect(diff[0].kind).to.be('E');
          expect(diff[1]).to.have.property('kind');
          expect(diff[1].kind).to.be('N');
        });

      });

      describe('if the filtered property is not an array', function () {

        it('changes do not appear as a difference', function () {
          var prefilter = function (path, key) {
            return key === 'fixedBy';
          };
          var diff = deep(lhs, rhs, prefilter);
          expect(diff).to.be.ok();
          expect(diff.length).to.be(4);
          expect(diff[0]).to.have.property('kind');
          expect(diff[0].kind).to.be('A');
          expect(diff[1]).to.have.property('kind');
          expect(diff[1].kind).to.be('A');
          expect(diff[2]).to.have.property('kind');
          expect(diff[2].kind).to.be('A');
          expect(diff[3]).to.have.property('kind');
          expect(diff[3].kind).to.be('E');
        });

      });
    });

    describe('A target that has nested values', function () {
      var nestedOne = {
        noChange: 'same',
        levelOne: {
          levelTwo: 'value'
        },
        arrayOne: [{
          objValue: 'value'
        }]
      };
      var nestedTwo = {
        noChange: 'same',
        levelOne: {
          levelTwo: 'another value'
        },
        arrayOne: [{
          objValue: 'new value'
        }, {
          objValue: 'more value'
        }]
      };

      it('shows no differences when compared to itself', function () {
        expect(deep.diff(nestedOne, nestedOne)).to.be.an('undefined');
      });

      it('shows the property as removed when compared to an empty object', function () {
        var diff = deep(nestedOne, empty);
        expect(diff).to.be.ok();
        expect(diff.length).to.be(3);
        expect(diff[0]).to.have.property('kind');
        expect(diff[0].kind).to.be('D');
        expect(diff[1]).to.have.property('kind');
        expect(diff[1].kind).to.be('D');
      });

      it('shows the property is changed when compared to an object that has value', function () {
        var diff = deep.diff(nestedOne, nestedTwo);
        expect(diff).to.be.ok();
        expect(diff.length).to.be(3);
      });

      it('shows the property as added when compared to an empty object on left', function () {
        var diff = deep.diff(empty, nestedOne);
        expect(diff).to.be.ok();
        expect(diff.length).to.be(3);
        expect(diff[0]).to.have.property('kind');
        expect(diff[0].kind).to.be('N');
      });

      describe('when diff is applied to a different empty object', function () {
        var diff = deep.diff(nestedOne, nestedTwo);

        it('has result with nested values', function () {
          var result = {};

          deep.applyChange(result, nestedTwo, diff[0]);
          expect(result.levelOne).to.be.ok();
          expect(result.levelOne).to.be.an('object');
          expect(result.levelOne.levelTwo).to.be.ok();
          expect(result.levelOne.levelTwo).to.eql('another value');
        });

        it('has result with array object values', function () {
          var result = {};

          deep.applyChange(result, nestedTwo, diff[2]);
          expect(result.arrayOne).to.be.ok();
          expect(result.arrayOne).to.be.an('array');
          expect(result.arrayOne[0]).to.be.ok();
          expect(result.arrayOne[0].objValue).to.be.ok();
          expect(result.arrayOne[0].objValue).to.equal('new value');
        });

        it('has result with added array objects', function () {
          var result = {};

          deep.applyChange(result, nestedTwo, diff[1]);
          expect(result.arrayOne).to.be.ok();
          expect(result.arrayOne).to.be.an('array');
          expect(result.arrayOne[1]).to.be.ok();
          expect(result.arrayOne[1].objValue).to.be.ok();
          expect(result.arrayOne[1].objValue).to.equal('more value');
        });
      });
    });

    describe('regression test for bug #10, ', function () {
      var lhs = {
        id: 'Release',
        phases: [{
          id: 'Phase1',
          tasks: [{
            id: 'Task1'
          }, {
            id: 'Task2'
          }]
        }, {
          id: 'Phase2',
          tasks: [{
            id: 'Task3'
          }]
        }]
      };
      var rhs = {
        id: 'Release',
        phases: [{
          // E: Phase1 -> Phase2
          id: 'Phase2',
          tasks: [{
            id: 'Task3'
          }]
        }, {
          id: 'Phase1',
          tasks: [{
            id: 'Task1'
          }, {
            id: 'Task2'
          }]
        }]
      };

      describe('differences in nested arrays are detected', function () {
        var diff = deep.diff(lhs, rhs);

        // there should be differences
        expect(diff).to.be.ok();
        expect(diff.length).to.be(6);

        it('differences can be applied', function () {
          var applied = deep.applyDiff(lhs, rhs);

          it('and the result equals the rhs', function () {
            expect(applied).to.eql(rhs);
          });

        });
      });

    });

    describe('regression test for bug #35', function () {
      var lhs = ['a', 'a', 'a'];
      var rhs = ['a'];

      it('can apply diffs between two top level arrays', function () {
        var differences = deep.diff(lhs, rhs);

        differences.forEach(function (it) {
          deep.applyChange(lhs, true, it);
        });

        expect(lhs).to.eql(['a']);
      });
    });

    describe('Objects from different frames', function () {
      if (typeof globalConflict === 'undefined') { return; }

      // eslint-disable-next-line no-undef
      var frame = document.createElement('iframe');
      // eslint-disable-next-line no-undef
      document.body.appendChild(frame);

      var lhs = new frame.contentWindow.Date(2010, 1, 1);
      var rhs = new frame.contentWindow.Date(2010, 1, 1);

      it('can compare date instances from a different frame', function () {
        var differences = deep.diff(lhs, rhs);

        expect(differences).to.be(undefined);
      });
    });

    describe('Comparing regexes should work', function () {
      var lhs = /foo/;
      var rhs = /foo/i;

      it('can compare regex instances', function () {
        var diff = deep.diff(lhs, rhs);

        expect(diff.length).to.be(1);

        expect(diff[0].kind).to.be('E');
        expect(diff[0].path).to.not.be.ok();
        expect(diff[0].lhs).to.be('/foo/');
        expect(diff[0].rhs).to.be('/foo/i');
      });
    });

    describe('subject.toString is not a function', function () {
      var lhs = {
        left: 'yes',
        right: 'no',
      };
      var rhs = {
        left: {
          toString: true,
        },
        right: 'no',
      };

      it('should not throw a TypeError', function () {
        var diff = deep.diff(lhs, rhs);

        expect(diff.length).to.be(1);
      });
    });

    describe('regression test for issue #83', function () {
      var lhs = {
        date: null
      };
      var rhs = {
        date: null
      };

      it('should not detect a difference', function () {
        expect(deep.diff(lhs, rhs)).to.be(undefined);
      });
    });

    describe('regression test for issue #70', function () {

      it('should detect a difference with undefined property on lhs', function () {
        var diff = deep.diff({ foo: undefined }, {});

        expect(diff).to.be.an(Array);
        expect(diff.length).to.be(1);

        expect(diff[0].kind).to.be('D');
        expect(diff[0].path).to.be.an('array');
        expect(diff[0].path).to.have.length(1);
        expect(diff[0].path[0]).to.be('foo');
        expect(diff[0].lhs).to.be(undefined);

      });

      it('should detect a difference with undefined property on rhs', function () {
        var diff = deep.diff({}, { foo: undefined });

        expect(diff).to.be.an(Array);
        expect(diff.length).to.be(1);

        expect(diff[0].kind).to.be('N');
        expect(diff[0].path).to.be.an('array');
        expect(diff[0].path).to.have.length(1);
        expect(diff[0].path[0]).to.be('foo');
        expect(diff[0].rhs).to.be(undefined);

      });
    });

    describe('regression test for issue #98', function () {
      var lhs = { foo: undefined };
      var rhs = { foo: undefined };

      it('should not detect a difference with two undefined property values', function () {
        var diff = deep.diff(lhs, rhs);

        expect(diff).to.be(undefined);

      });
    });

    describe('regression tests for issue #102', function () {
      it('should not throw a TypeError', function () {

        var diff = deep.diff(null, undefined);

        expect(diff).to.be.an(Array);
        expect(diff.length).to.be(1);

        expect(diff[0].kind).to.be('D');
        expect(diff[0].lhs).to.be(null);

      });

      it('should not throw a TypeError', function () {

        var diff = deep.diff(Object.create(null), { foo: undefined });

        expect(diff).to.be.an(Array);
        expect(diff.length).to.be(1);

        expect(diff[0].kind).to.be('N');
        expect(diff[0].rhs).to.be(undefined);
      });
    });

    describe('regression test for issue #141', function() {
      var changeFail = { kind: 'E', path: ['foo'], lhs: true, rhs: false };
      var changeSucceed = { kind: 'E', path: ['foo'], lhs: 1, rhs: 3 };

      var revertLHSFalsey = { kind: 'E', path: ['foo'], lhs: -1, rhs: 1 };
      var revertBothFalsey = { kind: 'E', path: ['foo'], lhs: -1, rhs: -3 };
      var revertLHSTruthy = { kind: 'E', path: ['foo'], lhs: 1, rhs: 3 };
      var revertBothTruthy = { kind: 'E', path: ['foo'], lhs: 1, rhs: 3 };

      it('applies changes correctly when the new value is truthy', function() {
        var target = { foo: changeSucceed.lhs };
        deep.applyChange(target, changeSucceed);
        expect(target.foo).to.equal(changeSucceed.rhs);
      });

      it('applies changes correctly when the new value is falsey', function() {
        var target = { foo: changeFail.lhs };
        deep.applyChange(target, changeFail);
        expect(target.foo).to.equal(changeFail.rhs);
      });

      it('reverts changes correctly when both values are truthy', function() {
        var target = { foo: 'hello' };
        deep.revertChange(target, revertBothTruthy);
        expect(target.foo).to.equal(revertBothTruthy.lhs);
      });

      it('reverts changes correctly when both values are falsey', function() {
        var target = { foo: 'hello' };
        deep.revertChange(target, revertBothFalsey);
        expect(target.foo).to.equal(revertBothFalsey.lhs);
      });

      it('reverts changes correctly when the new value is truthy', function() {
        var target = { foo: revertLHSTruthy.rhs };
        deep.revertChange(target, revertLHSTruthy);
        expect(target.foo).to.equal(revertLHSTruthy.lhs);
      });

      it('reverts changes correctly when the new value is falsey', function() {
        var target = { foo: revertLHSFalsey.rhs };
        deep.revertChange(target, revertLHSFalsey);
        expect(target.foo).to.equal(revertLHSFalsey.lhs);
      });

    });

    describe('Order independent hash testing', function () {
      function sameHash(a, b) {
        expect(deep.orderIndepHash(a)).to.equal(deep.orderIndepHash(b));
      }

      function differentHash(a, b) {
        expect(deep.orderIndepHash(a)).to.not.equal(deep.orderIndepHash(b));
      }

      describe('Order indepdendent hash function should give different values for different objects', function () {
        it('should give different values for different "simple" types', function () {
          differentHash(1, -20);
          differentHash('foo', 45);
          differentHash('pie', 'something else');
          differentHash(1.3332, 1);
          differentHash(1, null);
          differentHash('this is kind of a long string, don\'t you think?', 'the quick brown fox jumped over the lazy doge');
          differentHash(true, 2);
          differentHash(false, 'flooog');
        });

        it('should give different values for string and object with string', function () {
          differentHash('some string', { key: 'some string' });
        });

        it('should give different values for number and array', function () {
          differentHash(1, [1]);
        });

        it('should give different values for string and array of string', function () {
          differentHash('string', ['string']);
        });

        it('should give different values for boolean and object with boolean', function () {
          differentHash(true, { key: true });
        });

        it('should give different values for different arrays', function () {
          differentHash([1, 2, 3], [1, 2]);
          differentHash([1, 4, 5, 6], ['foo', 1, true, undefined]);
          differentHash([1, 4, 6], [1, 4, 7]);
          differentHash([1, 3, 5], ['1', '3', '5']);
        });

        it('should give different values for different objects', function () {
          differentHash({ key: 'value' }, { other: 'value' });
          differentHash({ a: { b: 'c' } }, { a: 'b' });
        });

        it('should differentiate between arrays and objects', function () {
          differentHash([1, true, '1'], { a: 1, b: true, c: '1' });
        });
      });

      describe('Order independent hash function should work in pathological cases', function () {
        it('should work in funky javascript cases', function () {
          differentHash(undefined, null);
          differentHash(0, undefined);
          differentHash(0, null);
          differentHash(0, false);
          differentHash(0, []);
          differentHash('', []);
          differentHash(3.22, '3.22');
          differentHash(true, 'true');
          differentHash(false, 0);
        });

        it('should work on empty array and object', function () {
          differentHash([], {});
        });

        it('should work on empty object and undefined', function () {
          differentHash({}, undefined);
        });

        it('should work on empty array and array with 0', function () {
          differentHash([], [0]);
        });
      });

      describe('Order independent hash function should be order independent', function () {
        it('should not care about array order', function () {
          sameHash([1, 2, 3], [3, 2, 1]);
          sameHash(['hi', true, 9.4], [true, 'hi', 9.4]);
        });

        it('should not care about key order in an object', function () {
          sameHash({ foo: 'bar', foz: 'baz' }, { foz: 'baz', foo: 'bar' });
        });

        it('should work with complicated objects', function () {
          var obj1 = {
            foo: 'bar',
            faz: [
              1,
              'pie',
              {
                food: 'yum'
              }
            ]
          };

          var obj2 = {
            faz: [
              'pie',
              {
                food: 'yum'
              },
              1
            ],
            foo: 'bar'
          };

          sameHash(obj1, obj2);
        });
      });
    });


    describe('Order indepedent array comparison should work', function () {
      it('can compare simple arrays in an order independent fashion', function () {
        var lhs = [1, 2, 3];
        var rhs = [1, 3, 2];

        var diff = deep.orderIndependentDiff(lhs, rhs);
        expect(diff).to.be(undefined);
      });

      it('still works with repeated elements', function () {
        var lhs = [1, 1, 2];
        var rhs = [1, 2, 1];

        var diff = deep.orderIndependentDiff(lhs, rhs);
        expect(diff).to.be(undefined);
      });

      it('works on complex objects', function () {
        var obj1 = {
          foo: 'bar',
          faz: [
            1,
            'pie',
            {
              food: 'yum'
            }
          ]
        };

        var obj2 = {
          faz: [
            'pie',
            {
              food: 'yum'
            },
            1
          ],
          foo: 'bar'
        };

        var diff = deep.orderIndependentDiff(obj1, obj2);
        expect(diff).to.be(undefined);
      });

      it('should report some difference in non-equal arrays', function () {
        var lhs = [1, 2, 3];
        var rhs = [2, 2, 3];

        var diff = deep.orderIndependentDiff(lhs, rhs);
        expect(diff.length).to.be.ok();
      });


    });

  });

}));