6402d885f9
- Migrated all pages from Next.js to Astro - Added PDPA-compliant Privacy Policy (Thai) - Added PDPA-compliant Terms & Conditions (Thai) - Added Cookie Policy with disclosure (Thai) - Implemented cookie consent banner (client-side) - Integrated Umami Analytics placeholder - Blog system with 3 posts - Optimized Docker configuration for production - Static site build (184KB, 11 pages) - Ready for Easypanel deployment Backup: /Users/kunthawatgreethong/Gitea/dealplustech-backup-nextjs-20260309.tar.gz
760 lines
22 KiB
JavaScript
760 lines
22 KiB
JavaScript
(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();
|
|
});
|
|
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}));
|