Test only public API and use better test data

Author: emmenko

test/components/Connector.spec.js renamed to test/Connector.spec.js

@@ -1,5 +1,5 @@
 // import expect from 'expect';
-// import { Connector } from '../../src';
+// import { Connector } from '../src';
 
 describe('Components', () => {
   describe('Connector', () => {

test/components/Provider.spec.js renamed to test/Provider.spec.js

@@ -1,5 +1,5 @@
 // import expect from 'expect';
-// import { Provider } from '../../src';
+// import { Provider } from '../src';
 
 describe('Components', () => {
   describe('Provider', () => {

test/Redux.spec.js

@@ -0,0 +1,32 @@
+const ADD_TODO = 'ADD_TODO';
+const ADD_TODO_ASYNC = 'ADD_TODO_ASYNC';
+
+export const initialState = [];
+export const defaultText = 'Hello World!';
+export const constants = { ADD_TODO, ADD_TODO_ASYNC };
+
+export function todoStore(state = initialState, action) {
+  const { type } = action;
+  if (type === ADD_TODO || type === ADD_TODO_ASYNC) {
+    return [{
+      id: state[0] ? state[0].id + 1 : 1,
+      text: action.text
+    }, ...state];
+  }
+  return state;
+}
+
+export const todoActions = {
+  addTodo(text) {
+    return { type: ADD_TODO, text };
+  },
+
+  addTodoAsync(text, cb/* for testing only */) {
+    return dispatch => {
+      setTimeout(() => {
+        dispatch({ type: ADD_TODO_ASYNC, text });
+        cb();
+      }, 500);
+    };
+  }
+};

test/_helpers.js

@@ -0,0 +1,37 @@
+import expect from 'expect';
+import { bindActionCreators, createRedux } from '../src';
+import * as helpers from './_helpers';
+
+const { todoActions, todoStore } = helpers;
+
+describe('Utils', () => {
+  describe('bindActionCreators', () => {
+
+    let redux;
+
+    beforeEach(() => {
+      redux = createRedux({ todoStore });
+    });
+
+    it('should bind given actions to the dispatcher', done => {
+      let expectedCallCount = 2;
+      // just for monitoring the dispatched actions
+      redux.subscribe(() => {
+        expectedCallCount--;
+        if (expectedCallCount === 0) {
+          const state = redux.getState();
+          expect(state.todoStore).toEqual([
+            { id: 2, text: 'World' },
+            { id: 1, text: 'Hello' }
+          ]);
+          done();
+        }
+      });
+      const actions = bindActionCreators(todoActions, redux.dispatch);
+      expect(Object.keys(actions)).toEqual(Object.keys(todoActions));
+
+      actions.addTodo('Hello');
+      actions.addTodoAsync('World');
+    });
+  });
+});

test/bindActionCreators.spec.js

@@ -0,0 +1,9 @@
+// import expect from 'expect';
+// import { compose } from '../src';
+
+describe('Utils', () => {
+  describe('compose', () => {
+
+    it('should call map stores');
+  });
+});

test/compose.spec.js

@@ -1,5 +1,5 @@
 // import expect from 'expect';
-// import { composeStores } from '../../src';
+// import { composeStores } from '../src';
 
 describe('Utils', () => {
   describe('composeStores', () => {

test/utils/composeStores.spec.js renamed to test/composeStores.spec.js

@@ -1,5 +1,5 @@
 // import expect from 'expect';
-// import { connect } from '../../src';
+// import { connect } from '../src';
 
 describe('Decorators', () => {
   describe('connect', () => {

test/components/connect.spec.js renamed to test/connect.spec.js

@@ -1,55 +1,40 @@
 import expect from 'expect';
 import { createDispatcher, composeStores } from '../src';
 import thunkMiddleware from '../src/middleware/thunk';
+import * as helpers from './_helpers';
 
-const fakeState = { foo: 'bar' };
-const fakeAction = { type: 'FOO', foo: 'bar' };
-const fakeActionAsync = { type: 'FOO_ASYNC', fooAsync: 'barAsync' };
-
-function fakeStore(state = fakeState, action) {
-  const { type } = action;
-  if (type === 'FOO') {
-    return action.foo;
-  }
-  if (type === 'FOO_ASYNC') {
-    return action.fooAsync;
-  }
-  return state;
-}
-
-function foo() {
-  return fakeAction;
-}
-
-function fooAsync(cb/* for testing only */) {
-  return dispatch => {
-    setTimeout(() => {
-      dispatch(fakeActionAsync);
-      cb();
-    }, 500);
-  };
-}
+const { constants, defaultText, todoActions, todoStore } = helpers;
+const { addTodo, addTodoAsync } = todoActions;
+const { ADD_TODO } = constants;
 
 describe('createDispatcher', () => {
 
   it('should handle sync and async dispatches', done => {
     const spy = expect.createSpy(() => {});
     const dispatcher = createDispatcher(
-      composeStores({ fakeStore }),
+      composeStores({ todoStore }),
+      // we need this middleware to handle async actions
       getState => [thunkMiddleware(getState)]);
+
     expect(dispatcher).toBeA('function');
 
-    const dispatchFn = dispatcher(fakeState, spy);
-    expect(spy).toHaveBeenCalledWith({ fakeStore: fakeState });
+    const dispatchFn = dispatcher(undefined, spy);
+    expect(spy.calls.length).toBe(1);
+    expect(spy).toHaveBeenCalledWith({ todoStore: [] });
 
-    const fooAction = dispatchFn(foo());
-    expect(fooAction).toEqual(fakeAction);
+    const addTodoAction = dispatchFn(addTodo(defaultText));
+    expect(addTodoAction).toEqual({ type: ADD_TODO, text: defaultText });
     expect(spy.calls.length).toBe(2);
-    expect(spy).toHaveBeenCalledWith({ fakeStore: 'bar' });
+    expect(spy).toHaveBeenCalledWith({ todoStore: [
+      { id: 1, text: defaultText }
+    ] });
 
-    dispatchFn(fooAsync(() => {
+    dispatchFn(addTodoAsync(('Say hi!'), () => {
       expect(spy.calls.length).toBe(3);
-      expect(spy).toHaveBeenCalledWith({ fakeStore: 'barAsync' });
+      expect(spy).toHaveBeenCalledWith({ todoStore: [
+        { id: 2, text: 'Say hi!' },
+        { id: 1, text: defaultText }
+      ] });
       done();
     }));
   });

test/createDispatcher.spec.js

@@ -1,16 +1,19 @@
 import expect from 'expect';
 import { createRedux } from '../src';
+import * as helpers from './_helpers';
 
-const fakeState = { foo: 'bar' };
-
-function fakeStore() {
-  return fakeState;
-}
+const { defaultText, todoActions, todoStore } = helpers;
+const { addTodo } = todoActions;
 
 describe('createRedux', () => {
 
+  let redux;
+
+  beforeEach(() => {
+    redux = createRedux({ todoStore });
+  });
+
   it('should expose Redux public API', () => {
-    const redux = createRedux({ fakeStore });
     const methods = Object.keys(redux);
 
     expect(methods.length).toBe(5);
@@ -20,4 +23,34 @@ describe('createRedux', () => {
     expect(methods).toContain('getDispatcher');
     expect(methods).toContain('replaceDispatcher');
   });
+
+  it('should subscribe to changes', done => {
+    let state = redux.getState();
+    expect(state.todoStore).toEqual({});
+    redux.subscribe(() => {
+      state = redux.getState();
+      expect(state.todoStore).toEqual([{ id: 1, text: 'Hello World!' }]);
+      done();
+    });
+    redux.dispatch(addTodo(defaultText));
+  });
+
+  it('should unsubscribe a listener', () => {
+    const changeListenerSpy = expect.createSpy(() => {});
+    const unsubscribe = redux.subscribe(changeListenerSpy);
+
+    expect(changeListenerSpy.calls.length).toBe(0);
+
+    redux.dispatch(addTodo('Hello'));
+    expect(redux.getState().todoStore).toEqual([{ id: 1, text: 'Hello'}]);
+    expect(changeListenerSpy.calls.length).toBe(1);
+
+    unsubscribe();
+    redux.dispatch(addTodo('World'));
+    expect(redux.getState().todoStore).toEqual([
+      { id: 2, text: 'World'},
+      { id: 1, text: 'Hello'}
+    ]);
+    expect(changeListenerSpy.calls.length).toBe(1);
+  });
 });

test/createRedux.spec.js

@@ -1,5 +1,5 @@
 import expect from 'expect';
-import getDisplayName from '../../src/utils/getDisplayName';
+import getDisplayName from '../src/utils/getDisplayName';
 
 describe('Utils', () => {
   describe('getDisplayName', () => {

test/exports.spec.js

@@ -1,5 +1,5 @@
 // import expect from 'expect';
-// import { provide } from '../../src';
+// import { provide } from '../src';
 
 describe('Decorators', () => {
   describe('provide', () => {