@mintlab/kitchen-sink/dist/object.test.js

"use strict";

var test = require('tape');

var _require = require('./object'),
    cloneWithout = _require.cloneWithout,
    purge = _require.purge,
    extract = _require.extract,
    get = _require.get,
    filterProperties = _require.filterProperties,
    filterPropertiesOnValues = _require.filterPropertiesOnValues,
    performGetOnProperties = _require.performGetOnProperties;

var assign = Object.assign;

var sourceObject = function sourceObject() {
  return {
    foo: 'FOO',
    bar: 'BAR',
    quux: 'QUUX'
  };
}; // cloneWithout


test('cloneWithout()', function (assert) {
  {
    var actual = cloneWithout(sourceObject(), 'foo');
    var expected = {
      bar: 'BAR',
      quux: 'QUUX'
    };
    var message = 'can clone an object with one excluded property';
    assert.deepEqual(actual, expected, message);
  }
  {
    var _actual = cloneWithout(sourceObject(), 'foo', 'quux');

    var _expected = {
      bar: 'BAR'
    };
    var _message = 'can clone an object with multiple excluded properties';
    assert.deepEqual(_actual, _expected, _message);
  }
  assert.end();
}); // purge

test('purge()', function (assert) {
  var clone = assign({}, sourceObject());
  var actual = purge('foo', clone, 'quux');
  var expected = {
    bar: 'BAR'
  };
  var message = 'accepts its arguments in any order and returns an object without the supplied properties';
  assert.deepEqual(actual, expected, message);
  assert.end();
}); // extract

test('extract()', function (assert) {
  {
    var actual = extract('bar', sourceObject());
    var expected = ['BAR', {
      foo: 'FOO',
      quux: 'QUUX'
    }];
    var message = 'can extract a single property with the key as first argument';
    assert.deepEqual(actual, expected, message);
  }
  {
    var _actual2 = extract(sourceObject(), 'bar');

    var _expected2 = [{
      foo: 'FOO',
      quux: 'QUUX'
    }, 'BAR'];
    var _message2 = 'an extract a single property with the key as last argument';
    assert.deepEqual(_actual2, _expected2, _message2);
  }
  {
    var _actual3 = extract('quux', sourceObject(), 'foo');

    var _expected3 = ['QUUX', {
      bar: 'BAR'
    }, 'FOO'];
    var _message3 = 'can extract multiple properties in any argument order';
    assert.deepEqual(_actual3, _expected3, _message3);
  }
  {
    var func = function func() {
      extract('foo', 'bar');
    };

    var _message4 = 'throws if no argument is an object';
    assert.throws(func, null, _message4);
  }
  {
    var _func = function _func() {
      extract('quux', sourceObject(), 'foo', sourceObject());
    };

    var _message5 = 'throws if more than one argument is an object';
    assert.throws(_func, null, _message5);
  }
  assert.end();
}); // get

test('get()', function (assert) {
  {
    var actual = get(sourceObject(), 'foo');
    var expected = 'FOO';
    var message = 'returns the value of an object property';
    assert.deepEqual(actual, expected, message);
  }
  {
    var object = {
      foo: {
        bar: 'quux'
      }
    };

    var _actual4 = get(object, 'foo.bar');

    var _expected4 = 'quux';
    var _message6 = 'returns the value of a deep object property';
    assert.deepEqual(_actual4, _expected4, _message6);
  }
  {
    var _object = {
      foo: {
        bar: 'quux'
      }
    };

    var _actual5 = get(_object, 'foo[bar]');

    var _expected5 = 'quux';
    var _message7 = 'supports bracket property accessors';
    assert.deepEqual(_actual5, _expected5, _message7);
  }
  {
    var _object2 = {};

    var _actual6 = get(_object2, 'nil');

    var _expected6;

    var _message8 = 'returns `undefined` for an object property that does not exist';
    assert.deepEqual(_actual6, _expected6, _message8);
  }
  {
    var _object3 = {};

    var _actual7 = get(_object3, 'foo.bar');

    var _expected7;

    var _message9 = 'returns `undefined` for a deep object property that does not exist';
    assert.deepEqual(_actual7, _expected7, _message9);
  }
  assert.end();
}); // performGetOnProperties

test('performGetOnProperties()', function (assert) {
  var getters = {
    one: 'one',
    two: 'two.second',
    three: 'three.third.tripple'
  };
  var object = {
    one: 'first',
    two: {
      second: 'double'
    },
    three: {
      third: {
        tripple: 'trio'
      }
    }
  };
  var actual = performGetOnProperties(object, getters);
  var expected = {
    one: 'first',
    two: 'double',
    three: 'trio'
  };
  var message = 'can perform a get on all the properties';
  assert.deepEqual(actual, expected, message);
  assert.end();
}); //filterProperties

test('filterProperties()', function (assert) {
  {
    var clone = assign({}, sourceObject());
    var actual = filterProperties(clone, 'foo', 'bar');
    var expected = {
      foo: 'FOO',
      bar: 'BAR'
    };
    var message = 'returns the object with only the given properties';
    assert.deepEqual(actual, expected, message);
  }
  {
    var _clone = assign({}, sourceObject());

    var _actual8 = filterProperties(_clone, 'foo', 'bar', 'mismatch');

    var _expected8 = {
      foo: 'FOO',
      bar: 'BAR'
    };
    var _message10 = 'returns the object with only the given properties ignoring non-matching properties';
    assert.deepEqual(_actual8, _expected8, _message10);
  }
  {
    var _clone2 = assign({}, sourceObject());

    var _actual9 = filterProperties(_clone2, 'mismatch', 'different');

    var _expected9 = {};
    var _message11 = 'and returns an empty object when none of the properties match';
    assert.deepEqual(_actual9, _expected9, _message11);
  }
  assert.end();
}); //filterPropertiesOnValues

test('filterPropertiesOnValues()', function (assert) {
  {
    var clone = assign({}, sourceObject());
    var actual = filterPropertiesOnValues(clone, function (value) {
      return value !== 'FOO';
    });
    var expected = {
      bar: 'BAR',
      quux: 'QUUX'
    };
    var message = 'and returns an object without the values for which the given function does not return true';
    assert.deepEqual(actual, expected, message);
  }
  {
    var _clone3 = assign({}, sourceObject());

    var _actual10 = filterPropertiesOnValues(_clone3, function (value) {
      return value !== 'mismatch';
    });

    var _expected10 = {
      foo: 'FOO',
      bar: 'BAR',
      quux: 'QUUX'
    };
    var _message12 = 'and returns an object without the values for which the given function does not return true';
    assert.deepEqual(_actual10, _expected10, _message12);
  }
  assert.end();
});