@schukai/monster 4.153.1 → 4.154.1

package/test/cases/util/clone.mjs

@@ -210,4 +210,119 @@ describe('Clone', function () {
 
     });
 
+    describe('cyclic graphs and constructor free copies issue #573', function () {
+
+        class NeedsArgument {
+            constructor(required) {
+                if (required === undefined) {
+                    throw new Error("required argument missing");
+                }
+                this.required = required;
+            }
+
+            describe() {
+                return `value:${this.required}`;
+            }
+        }
+
+        // net: behaviour that is already correct and must stay correct
+        it('should keep cloning plain nested structures deeply', function () {
+            let source = {a: {b: {c: 1}}, list: [1, {d: 2}]};
+            let result = clone(source);
+
+            expect(result).to.deep.equal(source);
+            expect(result.a).not.to.equal(source.a);
+            expect(result.list[1]).not.to.equal(source.list[1]);
+        });
+
+        it('should keep the prototype and instanceof of a cloned class instance', function () {
+            let source = new A({x: 1});
+            let result = clone(source);
+
+            expect(result).to.be.instanceOf(A);
+            expect(Object.getPrototypeOf(result)).to.equal(Object.getPrototypeOf(source));
+            expect(typeof result.a).to.equal('function');
+            expect(result.b).to.deep.equal({x: 1});
+        });
+
+        it('should keep honoring getClone()', function () {
+            let result = clone(new B({x: 1}));
+            expect(result).to.equal('DONE');
+        });
+
+        // regression: a cyclic graph must terminate instead of exhausting the stack
+        it('should clone a self referencing object', function () {
+            let source = {name: 'root'};
+            source.self = source;
+
+            let result = clone(source);
+
+            expect(result).not.to.equal(source);
+            expect(result.name).to.equal('root');
+            expect(result.self).to.equal(result);
+        });
+
+        it('should clone a cycle that runs through an array', function () {
+            let source = {items: []};
+            source.items.push(source);
+
+            let result = clone(source);
+
+            expect(result.items[0]).to.equal(result);
+            expect(result.items).not.to.equal(source.items);
+        });
+
+        it('should clone a mutual reference between two objects', function () {
+            let first = {name: 'first'};
+            let second = {name: 'second', first};
+            first.second = second;
+
+            let result = clone(first);
+
+            expect(result.second.first).to.equal(result);
+            expect(result.second).not.to.equal(second);
+        });
+
+        it('should preserve a shared reference instead of duplicating it', function () {
+            let shared = {value: 1};
+            let source = {left: shared, right: shared};
+
+            let result = clone(source);
+
+            expect(result.left).to.equal(result.right);
+            expect(result.left).not.to.equal(shared);
+        });
+
+        it('should keep honoring getClone() for an object reached inside a cycle', function () {
+            let source = {inner: new B({x: 1})};
+            source.self = source;
+
+            let result = clone(source);
+
+            expect(result.inner).to.equal('DONE');
+            expect(result.self).to.equal(result);
+        });
+
+        // regression: copying must not run the constructor of the source class
+        it('should clone an instance whose constructor requires an argument', function () {
+            let source = new NeedsArgument('payload');
+
+            let result = clone(source);
+
+            expect(result).to.be.instanceOf(NeedsArgument);
+            expect(result).not.to.equal(source);
+            expect(result.required).to.equal('payload');
+            expect(result.describe()).to.equal('value:payload');
+        });
+
+        it('should clone a nested instance whose constructor requires an argument', function () {
+            let source = {level: {instance: new NeedsArgument(7)}};
+
+            let result = clone(source);
+
+            expect(result.level.instance).to.be.instanceOf(NeedsArgument);
+            expect(result.level.instance.required).to.equal(7);
+        });
+    });
+
 });