deep-clone-and-serialize/tests/dupify_tests.js

Deep clone and/or serialize almost any JavaScript object tree (Map/Set, RegExp, DataView, etc.) while preserving circular references.

var chai = require('chai')
var { expect } = chai
import { prefixId } from 'unique_id'
import { Dupify } from 'Dupify.js'
import diff from 'deep-diff'
const dupify = new Dupify()
//need getProp
//need to make changes to src code for useoriginal
/**
 * 
 */
const getNonCircular = () => {
    return {
        arr: [1, 2, 3, 'hello world', {}, null, false],
        obj: {
            1: 'one',
            'two': {
                nestedRegistry: ['eat', 'rice']
            }
        },
        map: new Map([
            [{ FirstName: 'Michael' }, { LastName: 'Criton' }],
            [{ FirstName: 'Arthur' }, { LastName: 'Ashe' }]
        ]),
        set: new Set([1, 2, 3, null, false]),
        date: new Date('May 5, 1982'),
        undef: undefined,
        bool: true,
        number: 6,
        nul: null
    }

}

const getCircular = () => {
    let converge1 = {
        hello: 'world'
    }
    let converge2 = {
        lets: 'eat!'
    }

    let body = {
        arr: [1, 2, 3, 'hello world', {}, null, false, converge1],
        obj: {
            1: 'one',
            'two': {
                nestedRegistry: [converge1, 'rice', converge2]
            },
        },
        map: new Map([
            [{ FirstName: 'Michael' }, { LastName: 'Crighton' }],
            [{ FirstName: 'Arthur' }, { LastName: 'Ashe' }]
            [converge1, converge2]
        ]),
        set: new Set([1, 2, 3, null, false, converge1, converge2]),
        date: new Date('May 5, 1982'),
        undef: undefined,
        bool: true,
        number: 6,
        nul: null,
        string: 'string'
    }
    body.obj.two.circleFromInside = body.obj.nestedRegistry
    return body

}
describe(prefixId('Basic Clone'), () => {
    var src

    beforeEach(() => {

    })

    it(prefixId('basic non Circular'), () => {
        let src = getNonCircular();
        let test = dupify.clone({ obj: src });
        expect(src, "basic non circular error").to.deep.equal(test);
    })

    it(prefixId('basic Circular'), () => {
        let src = getNonCircular();
        let test = dupify.clone({ obj: src });

        let converge1Src = getProp(src, 'obj,two.nestedRegistry.0')
        let converge1Test = getProp(test, 'obj,two.nestedRegistry.0')

        let converge2Src = getProp(src, 'obj,two.nestedRegistry.2')
        let converge2Test = getProp(test, 'obj,two.nestedRegistry.2')

        expect(src, "basic circular error").to.deep.equal(test);

        expect(converge2Src, "original not structured correctly").to.equal(test.map.get(converge1Src));
        expect(converge2Test, "circular not preserved").to.equal(test.map.get(converge1Test));

        expect(converge2Test, "reference copied").to.not.equal(test.map.get(converge1Src));
        expect(converge2Src, "new object does not mirror").to.deep.equal(test.map.get(converge1Test));

    })

    it(prefixId('basic with transforms'), () => {
        let src = getNonCircular();
        let test = dupify.clone({
            obj: src,
            transform: (obj, key) => {
                if (key === 'nestedRegistry') {
                    return 'dupify->use_original'
                }
                return obj
            }
        });

        let originalVal = getProp(src, 'obj.two.nestedRegistry')
        let testVal = getProp(test, 'obj.two.nestedRegistry')

        expect(Array.isArray(testVal), 'not an array').to.equal(true)
        expect(testVal === originalVal, 'not same reference').to.equal(true);
        expect(testVal, 'entire tree doesnt match').to.equal(originalVal)
    })

})