@aws-solutions-constructs/core 2.78.0 → 2.79.0

package/node_modules/deep-diff/test/tests.js

@@ -0,0 +1,759 @@
+(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('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();
+      });
+
+
+    });
+
+  });
+
+}));