jrtechs-vis/test/util.test.js

var assert = require('assert');
var util = require('../lib/util');


describe('util', function () {

/**
 * Tests for copy and extend methods.
 *
 * Goal: to cover all possible paths within the tested method(s)
 *
 *
 * **NOTES**
 *
 * - All these methods have the inherent flaw that it's possible to define properties
 *   on an object with value 'undefined'. e.g. in `node`:
 *
 *    > a = { b:undefined }
 *    > a.hasOwnProperty('b')
 *    true
 *
 *   The logic for handling this in the code is minimal and accidental. For the time being,
 *   this flaw is ignored.
 */
describe('extend routines', function () {

  /**
   * Check if values have been copied over from b to a as intended
   */
  function checkExtended(a, b, checkCopyTarget = false) {
    var result = {
      color: 'green',
      sub: {
        enabled: false,
        sub2: {
          font: 'awesome'
        }
      }
    };

    assert(a.color !== undefined && a.color === result.color);
    assert(a.notInSource === true);
    if (checkCopyTarget) {
      assert(a.notInTarget === true);
    } else {
      assert(a.notInTarget === undefined);
    }

    var sub = a.sub;
    assert(sub !== undefined);
    assert(sub.enabled !== undefined && sub.enabled === result.sub.enabled);
    assert(sub.notInSource === true);
    if (checkCopyTarget) {
      assert(sub.notInTarget === true);
    } else {
      assert(sub.notInTarget === undefined);
    }

    sub = a.sub.sub2;
    assert(sub !== undefined);
    assert(sub !== undefined && sub.font !== undefined && sub.font === result.sub.sub2.font);
    assert(sub.notInSource === true);
    assert(a.subNotInSource !== undefined);
    if (checkCopyTarget) {
      assert(a.subNotInTarget.enabled === true);
      assert(sub.notInTarget === true);
    } else {
      assert(a.subNotInTarget === undefined);
      assert(sub.notInTarget === undefined);
    }
  }


  /**
   * Spot check on values of a unchanged as intended
   */
  function testAUnchanged(a) {
    var sub = a.sub;
    assert(sub !== undefined);
    assert(sub.enabled !== undefined && sub.enabled === true);
    assert(sub.notInSource === true);
    assert(sub.notInTarget === undefined);
    assert(sub.deleteThis === true);

    sub = a.sub.sub2;
    assert(sub !== undefined);
    assert(sub !== undefined && sub.font !== undefined && sub.font === 'arial');
    assert(sub.notInSource === true);
    assert(sub.notInTarget === undefined);

    assert(a.subNotInSource !== undefined);
    assert(a.subNotInTarget === undefined);
  }


  function initA() {
    return {
      color: 'red',
      notInSource: true,
      sub: {
        enabled: true,
        notInSource: true,
        sub2: {
          font: 'arial',
          notInSource: true,
        },
        deleteThis: true,
      },
      subNotInSource: {
        enabled: true,
      },
      deleteThis: true,
      subDeleteThis: {
        enabled: true,
      },
    };
  }


  beforeEach(function() {
    this.a = initA();

    this.b = {
      color: 'green',
      notInTarget: true,
      sub: {
        enabled: false,
        notInTarget: true,
        sub2: {
          font: 'awesome',
          notInTarget: true,
        },
        deleteThis: null,
      },
      subNotInTarget: {
        enabled: true,
      },
      deleteThis: null,
      subDeleteThis: null
    };
  });


  it('performs fillIfDefined() as advertized', function () {
    var a = this.a;
    var b = this.b;

    util.fillIfDefined(a, b);
    checkExtended(a, b);

    // NOTE: if allowDeletion === false, null values are copied over!
    //       This is due to existing logic; it might not be the intention and hence a bug
    assert(a.sub.deleteThis === null);
    assert(a.deleteThis === null);
    assert(a.subDeleteThis === null);
  });


  it('performs fillIfDefined() as advertized with deletion', function () {
    var a = this.a;
    var b = this.b;

    util.fillIfDefined(a, b, true);  //  thrid param: allowDeletion
    checkExtended(a, b);

    // Following should be removed now
    assert(a.sub.deleteThis === undefined);
    assert(a.deleteThis === undefined);
    assert(a.subDeleteThis === undefined);
  });


  it('performs selectiveDeepExtend() as advertized', function () {
    var a = this.a;
    var b = this.b;

    // pedantic: copy nothing
    util.selectiveDeepExtend([], a, b);
    assert(a.color !== undefined && a.color === 'red');
    assert(a.notInSource === true);
    assert(a.notInTarget === undefined);

    // pedantic: copy nonexistent property (nothing happens)
    assert(b.iDontExist === undefined);
    util.selectiveDeepExtend(['iDontExist'], a, b, true);
    assert(a.iDontExist === undefined);

    // At this point nothing should have changed yet.
    testAUnchanged(a);

    // Copy one property
    util.selectiveDeepExtend(['color'], a, b);
    assert(a.color !== undefined && a.color === 'green');

    // Copy property Object
    var sub = a.sub;
    assert(sub.deleteThis === true); // pre
    util.selectiveDeepExtend(['sub'], a, b);
    assert(sub !== undefined);
    assert(sub.enabled !== undefined && sub.enabled === false);
    assert(sub.notInSource === true);
    assert(sub.notInTarget === true);
    assert(sub.deleteThis === null);


    // Copy new Objects
    assert(a.notInTarget === undefined);     // pre
    assert(a.subNotInTarget === undefined);  // pre
    util.selectiveDeepExtend(['notInTarget', 'subNotInTarget'], a, b);
    assert(a.notInTarget === true);
    assert(a.subNotInTarget.enabled === true);

    // Copy null objects
    assert(a.deleteThis !== null);    // pre
    assert(a.subDeleteThis !== null); // pre
    util.selectiveDeepExtend(['deleteThis', 'subDeleteThis'], a, b);

    // NOTE: if allowDeletion === false, null values are copied over!
    //       This is due to existing logic; it might not be the intention and hence a bug
    assert(a.deleteThis === null);
    assert(a.subDeleteThis === null);
  });


  it('performs selectiveDeepExtend() as advertized with deletion', function () {
    var a = this.a;
    var b = this.b;

    // Only test expected differences here with test allowDeletion === false

    // Copy object property with properties to be deleted
    var sub = a.sub;
    assert(sub.deleteThis === true);      // pre
    util.selectiveDeepExtend(['sub'], a, b, true);
    assert(sub.deleteThis === undefined); // should be deleted

    // Spot check on rest of properties in `a.sub` - there should have been copied
    sub = a.sub;
    assert(sub !== undefined);
    assert(sub.enabled !== undefined && sub.enabled === false);
    assert(sub.notInSource === true);
    assert(sub.notInTarget === true);

    // Copy null objects
    assert(a.deleteThis === true);            // pre
    assert(a.subDeleteThis !== undefined);    // pre
    assert(a.subDeleteThis.enabled === true); // pre
    util.selectiveDeepExtend(['deleteThis', 'subDeleteThis'], a, b, true);
    assert(a.deleteThis === undefined);       // should be deleted
    assert(a.subDeleteThis === undefined);    // should be deleted
  });


  it('performs selectiveNotDeepExtend() as advertized', function () {
    var a = this.a;
    var b = this.b;

    // Exclude all properties, nothing copied
    util.selectiveNotDeepExtend(Object.keys(b), a, b);
    testAUnchanged(a);

    // Exclude nothing, everything copied
    util.selectiveNotDeepExtend([], a, b);
    checkExtended(a, b, true);

    // Exclude some
    a = initA();
    assert(a.notInTarget === undefined);     // pre
    assert(a.subNotInTarget === undefined);  // pre
    util.selectiveNotDeepExtend(['notInTarget', 'subNotInTarget'], a, b);
    assert(a.notInTarget === undefined);     // not copied
    assert(a.subNotInTarget === undefined);  // not copied
    assert(a.sub.notInTarget === true);      // copied!
  });


  it('performs selectiveNotDeepExtend() as advertized with deletion', function () {
    var a = this.a;
    var b = this.b;

    // Exclude all properties, nothing copied
    util.selectiveNotDeepExtend(Object.keys(b), a, b, true);
    testAUnchanged(a);

    // Exclude nothing, everything copied and some deleted
    util.selectiveNotDeepExtend([], a, b, true);
    checkExtended(a, b, true);

    // Exclude some
    a = initA();
    assert(a.notInTarget === undefined);      // pre
    assert(a.subNotInTarget === undefined);   // pre
    assert(a.deleteThis === true);            // pre
    assert(a.subDeleteThis !== undefined);    // pre
    assert(a.sub.deleteThis === true);        // pre
    assert(a.subDeleteThis.enabled === true); // pre
    util.selectiveNotDeepExtend(['notInTarget', 'subNotInTarget'], a, b, true);
    assert(a.deleteThis === undefined);       // should be deleted
    assert(a.sub.deleteThis !== undefined);   // not deleted! Original logic, could be a bug
    assert(a.subDeleteThis === undefined);    // should be deleted
    // Spot check: following should be same as allowDeletion === false
    assert(a.notInTarget === undefined);      // not copied
    assert(a.subNotInTarget === undefined);   // not copied
    assert(a.sub.notInTarget === true);       // copied!
  });


  /**
   * NOTE: parameter `protoExtend` not tested here!
   */
  it('performs deepExtend() as advertized', function () {
    var a = this.a;
    var b = this.b;

    util.deepExtend(a, b);
    checkExtended(a, b, true);
  });


  /**
   * NOTE: parameter `protoExtend` not tested here!
   */
  it('performs deepExtend() as advertized with delete', function () {
    var a = this.a;
    var b = this.b;

    // Copy null objects
    assert(a.deleteThis === true);            // pre
    assert(a.subDeleteThis !== undefined);    // pre
    assert(a.subDeleteThis.enabled === true); // pre
    util.deepExtend(a, b, false, true);
    checkExtended(a, b, true);                // Normal copy should be good
    assert(a.deleteThis === undefined);       // should be deleted
    assert(a.subDeleteThis === undefined);    // should be deleted
    assert(a.sub.deleteThis !== undefined);   // not deleted!!! Original logic, could be a bug
  });
});  // extend routines


//
// The important thing with mergeOptions() is that 'enabled' is always set in target option.
//
describe('mergeOptions', function () {

  it('handles good input without global options', function () {
    var options = {
      someValue: "silly value",
      aBoolOption: false,
      anObject: {
        answer:42
      },
      anotherObject: {
        enabled: false,
      },
      merge: null
    };

    // Case with empty target
    var mergeTarget  = {};

    util.mergeOptions(mergeTarget, options, 'someValue');
    assert(mergeTarget.someValue === undefined, 'Non-object option should not be copied');
    assert(mergeTarget.anObject === undefined);

    util.mergeOptions(mergeTarget, options, 'aBoolOption');
    assert(mergeTarget.aBoolOption !== undefined, 'option aBoolOption should now be an object');
    assert(mergeTarget.aBoolOption.enabled === false, 'enabled value option aBoolOption should have been copied into object');

    util.mergeOptions(mergeTarget, options, 'anObject');
    assert(mergeTarget.anObject !== undefined, 'Option object is not copied');
    assert(mergeTarget.anObject.answer === 42);
    assert(mergeTarget.anObject.enabled === true);

    util.mergeOptions(mergeTarget, options, 'anotherObject');
    assert(mergeTarget.anotherObject.enabled === false, 'enabled value from options must have priority');

    util.mergeOptions(mergeTarget, options, 'merge');
    assert(mergeTarget.merge === undefined, 'Explicit null option should not be copied, there is no global option for it');

    // Case with non-empty target
    mergeTarget  = {
      someValue: false,
      aBoolOption: true,
      anObject: {
        answer: 49
      },
      anotherObject: {
        enabled: true,
      },
      merge: 'hello'
    };

    util.mergeOptions(mergeTarget, options, 'someValue');
    assert(mergeTarget.someValue === false, 'Non-object option should not be copied');
    assert(mergeTarget.anObject.answer === 49, 'Sibling option should not be changed');

    util.mergeOptions(mergeTarget, options, 'aBoolOption');
    assert(mergeTarget.aBoolOption !== true, 'option enabled should have been overwritten');
    assert(mergeTarget.aBoolOption.enabled === false, 'enabled value option aBoolOption should have been copied into object');

    util.mergeOptions(mergeTarget, options, 'anObject');
    assert(mergeTarget.anObject.answer === 42);
    assert(mergeTarget.anObject.enabled === true);

    util.mergeOptions(mergeTarget, options, 'anotherObject');
    assert(mergeTarget.anotherObject !== undefined, 'Option object is not copied');
    assert(mergeTarget.anotherObject.enabled === false, 'enabled value from options must have priority');

    util.mergeOptions(mergeTarget, options, 'merge');
    assert(mergeTarget.merge === 'hello', 'Explicit null-option should not be copied, already present in target');
  });


  it('gracefully handles bad input', function () {
    var mergeTarget  = {};
    var options = {
      merge: null
    };

    var errMsg  = 'Non-object parameters should not be accepted';
    assert.throws(() => util.mergeOptions(null, options, 'anything'), Error, errMsg);
    assert.throws(() => util.mergeOptions(undefined, options, 'anything'), Error, errMsg);
    assert.throws(() => util.mergeOptions(42, options, 'anything'), Error, errMsg);
    assert.throws(() => util.mergeOptions(mergeTarget, null, 'anything'), Error, errMsg);
    assert.throws(() => util.mergeOptions(mergeTarget, undefined, 'anything'), Error, errMsg);
    assert.throws(() => util.mergeOptions(mergeTarget, 42, 'anything'), Error, errMsg);
    assert.throws(() => util.mergeOptions(mergeTarget, options, null), Error, errMsg);
    assert.throws(() => util.mergeOptions(mergeTarget, options, undefined), Error, errMsg);
    assert.throws(() => util.mergeOptions(mergeTarget, options, 'anything', null), Error, errMsg);
    assert.throws(() => util.mergeOptions(mergeTarget, options, 'anything', 'not an object'), Error, errMsg);


    util.mergeOptions(mergeTarget, options, 'iDontExist');
    assert(mergeTarget.iDontExist === undefined);
  });


  it('handles good input with global options', function () {
    var mergeTarget  = {
    };
    var options = {
      merge: null,
      missingEnabled: {
        answer: 42
      },
      alsoMissingEnabled: {  // has no enabled in globals
        answer: 42
      }
    };

    var globalOptions = {
      merge: {
        enabled: false
      },
      missingEnabled: {
        enabled: false
      }
    };

    util.mergeOptions(mergeTarget, options, 'merge', globalOptions);
    assert(mergeTarget.merge.enabled === false, "null-option should create an empty target object");

    util.mergeOptions(mergeTarget, options, 'missingEnabled', globalOptions);
    assert(mergeTarget.missingEnabled.enabled === false);

    util.mergeOptions(mergeTarget, options, 'alsoMissingEnabled', globalOptions);
    assert(mergeTarget.alsoMissingEnabled.enabled === true);
  });

});  // mergeOptions
});  // util