@v4fire/core/lib/core/object/proxy-clone/spec.js

V4Fire core library

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
var _proxyClone = _interopRequireDefault(require("../../../core/object/proxy-clone"));
describe('core/object/proxy-clone', () => {
  it('cloning an object', () => {
    const original = {
      user: {
        name: 'Bob',
        age: 56,
        skills: ['singing', 'dancing', 'programming']
      }
    };
    const clone = (0, _proxyClone.default)(original);
    clone.user.name = 'Jack';
    clone.user.skills.push('boxing');
    expect(clone.user.name).toBe('Jack');
    expect(original.user.name).toBe('Bob');
    expect(clone.user.skills).toEqual(['singing', 'dancing', 'programming', 'boxing']);
    expect(original.user.skills).toEqual(['singing', 'dancing', 'programming']);
    delete clone.user.name;
    expect(clone.user.name).toBe(undefined);
    expect('name' in clone.user).toBe(false);
    expect(original.user.name).toBe('Bob');
  });
  it('getting `Object.keys` from the clone object', () => {
    const original = {
      a: 1,
      b: [1, 2, 3]
    };
    const clone = (0, _proxyClone.default)(original);
    delete clone.a;
    clone.c = 10;
    expect(Object.keys(clone)).toEqual(['b', 'c']);
    clone.b.push(4);
    expect(Object.keys(clone.b)).toEqual(['0', '1', '2', '3']);
  });
  it('cloning an object with accessors', () => {
    const original = {
      user: {
        get name() {
          return 'Bob';
        },
        _age: 56,
        get age() {
          return this._age;
        },
        set age(value) {
          this._age = value * 2;
        }
      }
    };
    const clone = (0, _proxyClone.default)(original);
    expect(() => clone.user.name = 'Jack').toThrowError("'set' on proxy: trap returned falsish for property 'name'");
    clone.user.age = 5;
    expect(clone.user.age).toBe(10);
    expect(original.user.age).toBe(56);
    delete clone.user.name;
    expect(clone.user.name).toBe(undefined);
    expect('name' in clone.user).toBe(false);
    expect(original.user.name).toBe('Bob');
  });
  it('cloning an object with descriptors', () => {
    const original = {
      user: {
        name: 'Bob'
      }
    };
    const clone = (0, _proxyClone.default)(original);
    Object.defineProperty(original.user, 'age', {
      configurable: true,
      value: 56
    });
    expect(Object.getOwnPropertyDescriptor(clone.user, 'age')).toEqual({
      value: 56,
      writable: false,
      enumerable: false,
      configurable: true
    });
    expect(() => clone.user.age = 12).toThrowError("'set' on proxy: trap returned falsish for property 'age'");
    Object.defineProperty(clone.user, 'age', {
      writable: true,
      enumerable: true,
      configurable: true,
      value: 17
    });
    expect(clone.user.age).toBe(17);
    expect(Object.getOwnPropertyDescriptor(clone.user, 'age')).toEqual({
      value: 17,
      writable: true,
      enumerable: true,
      configurable: true
    });
    const blaGetter = () => 10;
    Object.defineProperty(clone, 'bla', {
      enumerable: true,
      get: blaGetter
    });
    expect(clone.bla).toBe(10);
    expect(Object.getOwnPropertyDescriptor(clone, 'bla')).toEqual({
      configurable: true,
      enumerable: true,
      get: blaGetter,
      set: undefined
    });
    Object.defineProperty(original.user, 'newAge', {
      writable: true,
      value: 56
    });
    expect(() => {
      delete clone.user.newAge;
    }).toThrowError("'deleteProperty' on proxy: trap returned falsish for property 'newAge'");
    Object.defineProperty(clone.user, 'newAge', {
      value: 46
    });
    expect(clone.user.newAge).toBe(46);
    expect(Object.getOwnPropertyDescriptor(clone.user, 'newAge')).toEqual({
      value: 46,
      writable: true,
      enumerable: false,
      configurable: false
    });
  });
  it('cloning an array', () => {
    const original = [{
      name: 'Bob',
      age: 56,
      skills: ['singing', 'dancing', 'programming']
    }];
    const clone = (0, _proxyClone.default)(original);
    clone[0].name = 'Jack';
    clone[0].skills.push('boxing');
    clone.push({
      name: 'Sam',
      age: 23
    });
    expect(clone[0].name).toBe('Jack');
    expect(original[0].name).toBe('Bob');
    expect(clone[0].skills).toEqual(['singing', 'dancing', 'programming', 'boxing']);
    expect(original[0].skills).toEqual(['singing', 'dancing', 'programming']);
    expect(clone).toEqual([{
      name: 'Jack',
      age: 56,
      skills: ['singing', 'dancing', 'programming', 'boxing']
    }, {
      name: 'Sam',
      age: 23
    }]);
    expect(original).toEqual([{
      name: 'Bob',
      age: 56,
      skills: ['singing', 'dancing', 'programming']
    }]);
  });
  it('cloning an object with Map/Set properties', () => {
    const original = new Map([['user', {
      name: 'Bob',
      age: 56,
      skills: new Set(['singing', 'dancing', 'programming'])
    }]]);
    const clone = (0, _proxyClone.default)(original);
    clone.get('user').name = 'Jack';
    clone.get('user').skills.add('boxing');
    expect(clone.get('user').name).toBe('Jack');
    expect(original.get('user').name).toBe('Bob');
    expect(clone.get('user').skills).toBeInstanceOf(Set);
    expect([...clone.get('user').skills]).toEqual(['singing', 'dancing', 'programming', 'boxing']);
    expect([...original.get('user').skills]).toEqual(['singing', 'dancing', 'programming']);
  });
  it('cloning an object with WeakMap/WeakSet properties', () => {
    const user = {},
      singing = {},
      dancing = {},
      programming = {},
      boxing = {};
    const original = new WeakMap([[user, {
      name: 'Bob',
      age: 56,
      skills: new WeakSet([singing, dancing, programming])
    }]]);
    const clone = (0, _proxyClone.default)(original);
    clone.get(user).name = 'Jack';
    clone.get(user).skills.add(boxing);
    expect(clone.get(user).name).toBe('Jack');
    expect(original.get(user).name).toBe('Bob');
    expect(clone.get(user).skills).toBeInstanceOf(WeakSet);
    expect(clone.get(user).skills.has(boxing)).toBe(true);
    expect(original.get(user).skills.has(boxing)).toBe(false);
  });
  it('cloning an iterable object', () => {
    const original = new Map([['user', {
      name: 'Bob',
      age: 56,
      skills: [{
        type: 'singing'
      }, {
        type: 'dancing'
      }],
      skillsSet: [{
        type: 'singing'
      }, {
        type: 'dancing'
      }]
    }]]);
    const clone = (0, _proxyClone.default)(original);
    for (const el of clone.get('user').skills) {
      el.type = [...el.type].reverse().join('');
    }
    expect([...clone.get('user').skills]).toEqual([{
      type: 'gnignis'
    }, {
      type: 'gnicnad'
    }]);
    expect([...original.get('user').skills]).toEqual([{
      type: 'singing'
    }, {
      type: 'dancing'
    }]);
    for (const el of clone.get('user').skillsSet) {
      el.type = [...el.type].reverse().join('');
    }
    expect([...clone.get('user').skillsSet]).toEqual([{
      type: 'gnignis'
    }, {
      type: 'gnicnad'
    }]);
    expect([...original.get('user').skillsSet]).toEqual([{
      type: 'singing'
    }, {
      type: 'dancing'
    }]);
  });
});