updeep-remeda/test/updeep-spec.js

156 lines
4.2 KiB
JavaScript
Raw Normal View History

import { expect } from 'chai';
2015-08-01 16:09:52 +00:00
import u from '../lib';
2015-07-31 15:53:25 +00:00
2015-08-01 15:13:25 +00:00
describe('updeep', () => {
it('does not change anything if no updates are specified', () => {
2015-08-05 07:27:56 +00:00
const object = { foo: 3, bar: [7, 5] };
const result = u({}, object);
expect(result).to.equal(object);
});
2015-08-01 15:13:25 +00:00
it('can update with fixed values', () => {
2015-08-05 07:27:56 +00:00
const object = { foo: 3, bar: [7, 5] };
const result = u({ foo: 4 }, object);
expect(result).to.deep.equal({ foo: 4, bar: [7, 5] });
});
2015-08-01 15:13:25 +00:00
it('returns the same instance if an update doesn\'t make changes', () => {
2015-08-05 07:27:56 +00:00
const object = { foo: 3 };
const result = u({ foo: 3 }, object);
expect(result).to.equal(object);
});
2015-08-01 15:13:25 +00:00
it('can update a nested structure', () => {
2015-08-05 07:27:56 +00:00
const object = { foo: { bar: 7, bam: 3 }, baz: 32 };
const result = u({ foo: { bar: 8 } }, object);
expect(result).to.deep.equal({ foo: { bar: 8, bam: 3 }, baz: 32 });
});
2015-08-01 15:13:25 +00:00
it('can update arrays', () => {
2015-08-05 07:27:56 +00:00
const object = [1, 2, 3];
const result = u({ 1: 7 }, object);
expect(result).to.deep.equal([1, 7, 3]);
});
it('replaces the object outright if updates are a constant', () => {
expect(u(3, {})).to.equal(3);
expect(u(null, {})).to.be.null;
});
it('can create array if all keys are numbers', () => {
const result = u({ 0: 'hi', '1': 'world' }, null);
expect(result).to.eql(['hi', 'world']);
});
it('does not create array if any key is not number', () => {
const result = u({ 0: 'hi', '1a': 'world' }, null);
expect(result).to.eql({ 0: 'hi', '1a': 'world' });
});
2015-08-01 15:13:25 +00:00
it('can add an element to an array', () => {
2015-08-05 07:27:56 +00:00
const object = [];
const result = u({ 0: 3 }, object);
expect(result).to.eql([3]);
});
2015-08-01 15:13:25 +00:00
it('can update nested arrays', () => {
2015-08-05 07:27:56 +00:00
const object = { foo: [1, 2, 3], bar: 9 };
const result = u({ foo: { 1: 7 } }, object);
expect(result).to.deep.equal({ foo: [1, 7, 3], bar: 9 });
});
2015-08-01 15:13:25 +00:00
it('can use functions to update values', () => {
const inc = (i) => i + 1;
2015-08-05 07:27:56 +00:00
const object = { foo: 3, bar: 4, baz: 7 };
const result = u({ foo: inc, bar: inc }, object);
expect(result).to.deep.equal({ foo: 4, bar: 5, baz: 7 });
});
2015-08-02 07:32:32 +00:00
it('can be partially applied', () => {
const inc = (i) => i + 1;
2015-08-05 07:27:56 +00:00
const object = { foo: 3 };
2015-08-01 16:09:52 +00:00
const incFoo = u({ foo: inc });
2015-08-05 07:27:56 +00:00
const result = incFoo(object);
expect(result).to.deep.equal({ foo: 4 });
});
it('passes additional arguments on to updates if it is a function', () => {
const func = (_, x) => x;
const result = u(func, 0, 4);
expect(result).to.equal(4);
});
it('can update if the value is an array', () => {
2015-08-05 07:27:56 +00:00
const object = {};
const result = u({ foo: [0, 1] }, object);
expect(result).to.deep.equal({ foo: [0, 1] });
});
it('can update when original object is undefined', () => {
2015-08-01 16:09:52 +00:00
const result = u({ foo: [0, 1] }, undefined);
expect(result).to.deep.equal({ foo: [0, 1] });
});
it('can take a function as the updater', () => {
2015-08-01 16:09:52 +00:00
const result = u(i => i + 1, 7);
expect(result).to.eql(8);
2015-07-31 15:53:25 +00:00
});
2015-08-01 16:09:52 +00:00
2015-08-02 07:32:32 +00:00
it('deeply freezes the result', () => {
const result = u({ foo: { bar: 3 } }, { foo: { bar: 0 } });
expect(Object.isFrozen(result)).to.be.true;
expect(Object.isFrozen(result.foo)).to.be.true;
2015-08-02 07:32:32 +00:00
});
2015-08-05 04:33:27 +00:00
it('assigns null values', () => {
expect(u({isNull: null}, {})).to.eql({isNull: null});
2015-08-05 04:33:27 +00:00
});
2015-08-12 15:35:10 +00:00
it('can use a placeholder to partially apply', () => {
function increment(i) { return i + 1; }
const updateJoe = u(u._, { name: 'Joe Merrill', age: 21 });
const result = updateJoe({ age: increment });
expect(result).to.eql({ name: 'Joe Merrill', age: 22 });
2015-08-12 15:35:10 +00:00
});
it('defaults to an empty object when null or undefined', () => {
let result = u({ a: { b: 0 } }, { a: null });
expect(result).to.eql({ a: { b: 0 } });
result = u({ a: { b: 0 } }, { a: undefined });
expect(result).to.eql({ a: { b: 0 } });
result = u({ a: { b: 0 } }, { });
expect(result).to.eql({ a: { b: 0 } });
});
it('preserves empty objects when empty updates are specified', () => {
const result = u({ a: {} }, {});
expect(result).to.eql({ a: {} });
});
it('works with date objects', () => {
const date = new Date();
const result = u({ created: date }, {});
expect(result).to.eql({ created: date });
});
2015-07-31 15:53:25 +00:00
});