Add unit tests for reducers

...and make them work (!)

Author: fzaninotto

src/resolver/Mutation/create.js

@@ -1,6 +1,8 @@
-export default entityData => (_, entity) => {
+export default (entityData = []) => (_, entity) => {
+    const newId =
+        entityData.length > 0 ? entityData[entityData.length - 1].id + 1 : 0;
     const newEntity = {
-        id: entityData[entityData.length - 1].id + 1,
+        id: newId,
         ...entity,
     };
 

src/resolver/Mutation/create.spec.js

@@ -0,0 +1,24 @@
+import create from './create';
+
+test('returns a new object with id 0 on empty datastore', () => {
+    expect(create()(null, {})).toEqual({ id: 0 });
+});
+
+test('returns a new object with incremental id', () => {
+    const data = [{ id: 1 }, { id: 3 }];
+    expect(create(data)(null, {})).toEqual({ id: 4 });
+});
+
+test('returns a new object using create data', () => {
+    const data = [{ id: 0, value: 'foo' }];
+    expect(create(data)(null, { value: 'toto' })).toEqual({
+        id: 1,
+        value: 'toto',
+    });
+});
+
+test('creates a new record', () => {
+    const data = [{ id: 1 }, { id: 3 }];
+    create(data)(null, { value: 'foo' });
+    expect(data).toEqual([{ id: 1 }, { id: 3 }, { id: 4, value: 'foo' }]);
+});

src/resolver/Mutation/remove.js

@@ -1,8 +1,8 @@
-export default entityData => (_, { id }) => {
+export default (entityData = []) => (_, { id }) => {
     const parsedId = parseInt(id, 10); // FIXME fails for non-integer ids
     const indexOfEntity = entityData.findIndex(e => e.id === parsedId);
     const removedEntity = entityData[indexOfEntity];
 
-    entityData = entityData.filter(e => e.id !== id);
+    entityData.splice(indexOfEntity, 1);
     return removedEntity;
 };

src/resolver/Mutation/remove.spec.js

@@ -0,0 +1,21 @@
+import remove from './remove';
+
+test('returns undefined by default', () => {
+    expect(remove()(null, {})).toBeUndefined();
+});
+
+test('returns removed record when found', () => {
+    const data = [{ id: 1, value: 'foo' }, { id: 2, value: 'bar' }];
+    expect(remove(data)(null, { id: 1 })).toEqual({ id: 1, value: 'foo' });
+});
+
+test('returns undefined when not found', () => {
+    const data = [{ id: 1, value: 'foo' }, { id: 2, value: 'bar' }];
+    expect(remove(data)(null, { id: 3 })).toBeUndefined();
+});
+
+test('removes record when found', () => {
+    const data = [{ id: 1, value: 'foo' }, { id: 2, value: 'bar' }];
+    remove(data)(null, { id: 1 });
+    expect(data).toEqual([{ id: 2, value: 'bar' }]);
+});

src/resolver/Mutation/update.js

@@ -1,10 +1,11 @@
-export default entityData => (_, { id, ...updates }) => {
+export default (entityData = []) => (_, { id, ...updates }) => {
     const parsedId = parseInt(id, 10); // FIXME fails for non-integer ids
     const indexOfEntity = entityData.findIndex(e => e.id === parsedId);
-
-    entityData[indexOfEntity] = {
-        ...entityData[indexOfEntity],
-        ...updates,
-    };
-    return entityData[indexOfEntity];
+    if (indexOfEntity !== -1) {
+        entityData[indexOfEntity] = {
+            ...entityData[indexOfEntity],
+            ...updates,
+        };
+        return entityData[indexOfEntity];
+    }
 };

src/resolver/Mutation/update.spec.js

@@ -0,0 +1,31 @@
+import update from './update';
+
+test('returns undefined by default', () => {
+    expect(update()(null, {})).toBeUndefined();
+});
+
+test('returns updated record when found', () => {
+    const data = [{ id: 1, value: 'foo', bar: 'baz' }];
+    expect(update(data)(null, { id: 1, value: 'bar' })).toEqual({
+        id: 1,
+        value: 'bar',
+        bar: 'baz',
+    });
+});
+
+test('returns undefined when not found', () => {
+    const data = [{ id: 1, value: 'foo' }, { id: 2, value: 'bar' }];
+    expect(update(data)(null, { id: 3 })).toBeUndefined();
+});
+
+test('updates record when found', () => {
+    const data = [{ id: 1, value: 'foo' }];
+    update(data)(null, { id: 1, value: 'bar', bar: 'baz' });
+    expect(data).toEqual([{ id: 1, value: 'bar', bar: 'baz' }]);
+});
+
+test('removes property when setting the value to undefined', () => {
+    const data = [{ id: 1, value: 'foo' }];
+    update(data)(null, { id: 1, value: undefined });
+    expect(data).toEqual([{ id: 1 }]);
+});

src/resolver/Query/single.js

@@ -1 +1,2 @@
-export default entityData => (_, { id }) => entityData.find(d => d.id == id);
+export default (entityData = []) => (_, { id }) =>
+    entityData.find(d => d.id == id);

src/resolver/Query/single.spec.js

@@ -0,0 +1,15 @@
+import single from './single';
+
+test('returns undefined by default', () => {
+    expect(single()(null, {})).toBeUndefined();
+});
+
+test('returns record when found', () => {
+    const data = [{ id: 1, value: 'foo' }, { id: 2, value: 'bar' }];
+    expect(single(data)(null, { id: 1 })).toEqual({ id: 1, value: 'foo' });
+});
+
+test('returns undefined when not found', () => {
+    const data = [{ id: 1, value: 'foo' }, { id: 2, value: 'bar' }];
+    expect(single(data)(null, { id: 3 })).toBeUndefined();
+});