Merge branch 'v1.0.0' into hygiene/check-reducers

Author: yangmillstheory

README.md

@@ -132,7 +132,7 @@ expect(actionThree(3)).to.deep.equal({
 });
 ```
 
-### `handleAction(type, reducer | reducerMap = Identity, ?defaultState)`
+### `handleAction(type, reducer | reducerMap = Identity, defaultState)`
 
 ```js
 import { handleAction } from 'redux-actions';
@@ -148,24 +148,24 @@ Otherwise, you can specify separate reducers for `next()` and `throw()` using th
 handleAction('FETCH_DATA', {
   next(state, action) {...},
   throw(state, action) {...}
-});
+}, defaultState);
 ```
 
 If either `next()` or `throw()` are `undefined` or `null`, then the identity function is used for that reducer. 
 
 If the reducer argument (`reducer | reducerMap`) is `undefined`, then the identity function is used.
 
-The optional third parameter specifies a default or initial state, which is used when `undefined` is passed to the reducer.
+The third parameter `defaultState` is required, and is used when `undefined` is passed to the reducer.
 
-### `handleActions(reducerMap, ?defaultState)`
+### `handleActions(reducerMap, defaultState)`
 
 ```js
 import { handleActions } from 'redux-actions';
 ```
 
 Creates multiple reducers using `handleAction()` and combines them into a single reducer that handles multiple actions. Accepts a map where the keys are passed as the first parameter to `handleAction()` (the action type), and the values are passed as the second parameter (either a reducer or reducer map).
 
-The optional second parameter specifies a default or initial state, which is used when `undefined` is passed to the reducer.
+The second parameter `defaultState` is required, and is used when `undefined` is passed to the reducer.
 
 (Internally, `handleActions()` works by applying multiple reducers in sequence using [reduce-reducers](https://github.com/acdlite/reduce-reducers).)
 

package.json

@@ -50,12 +50,13 @@
     "eslint-config-airbnb-base": "^1.0.3",
     "eslint-plugin-import": "^1.5.0",
     "eslint-watch": "^2.1.13",
-    "flux-standard-action": "^0.6.0",
     "mocha": "^2.2.5",
     "rimraf": "^2.5.3",
     "webpack": "^1.13.1"
   },
   "dependencies": {
+    "flux-standard-action": "^1.0.0",
+    "invariant": "^2.2.1",
     "lodash": "^4.13.1",
     "reduce-reducers": "^0.1.0"
   }

src/__tests__/createAction-test.js

@@ -93,11 +93,6 @@ describe('createAction()', () => {
         type
       });
 
-      const explictNullAction = createAction(type)(null);
-      expect(explictNullAction).to.deep.equal({
-        type
-      });
-
       const baz = '1';
       const actionCreator = createAction(type, null, () => ({ bar: baz }));
       expect(actionCreator()).to.deep.equal({

src/__tests__/handleAction-test.js

@@ -1,9 +1,11 @@
 import { expect } from 'chai';
+import identity from 'lodash/identity';
 import { handleAction, createAction, createActions, combineActions } from '../';
 
 describe('handleAction()', () => {
   const type = 'TYPE';
   const prevState = { counter: 3 };
+  const defaultState = { counter: 0 };
 
   it('should throw an error if the reducer is the wrong type', () => {
     const badReducers = [1, 'string', [], null];
@@ -26,9 +28,18 @@ describe('handleAction()', () => {
   });
 
   describe('single handler form', () => {
+    it('should throw an error if defaultState is not specified', () => {
+      expect(() => {
+        handleAction(type, undefined);
+      }).to.throw(
+        Error,
+        'defaultState for reducer handling TYPE should be defined'
+      );
+    });
+
     describe('resulting reducer', () => {
       it('returns previous state if type does not match', () => {
-        const reducer = handleAction('NOTTYPE', () => null);
+        const reducer = handleAction('NOTTYPE', () => null, defaultState);
         expect(reducer(prevState, { type })).to.equal(prevState);
       });
 
@@ -43,7 +54,7 @@ describe('handleAction()', () => {
       it('accepts single function as handler', () => {
         const reducer = handleAction(type, (state, action) => ({
           counter: state.counter + action.payload
-        }));
+        }), defaultState);
         expect(reducer(prevState, { type, payload: 7 }))
           .to.deep.equal({
             counter: 10
@@ -54,15 +65,15 @@ describe('handleAction()', () => {
         const incrementAction = createAction(type);
         const reducer = handleAction(incrementAction, (state, action) => ({
           counter: state.counter + action.payload
-        }));
+        }), defaultState);
 
         expect(reducer(prevState, incrementAction(7)))
           .to.deep.equal({
             counter: 10
           });
       });
 
-      it('accepts single function as handler and a default state', () => {
+      it('accepts a default state used when the previous state is undefined', () => {
         const reducer = handleAction(type, (state, action) => ({
           counter: state.counter + action.payload
         }), { counter: 3 });
@@ -78,20 +89,30 @@ describe('handleAction()', () => {
 
         const reducer = handleAction(increment, (state, { payload }) => ({
           counter: state.counter + payload
-        }), { counter: 3 });
+        }), defaultState);
 
         expect(reducer(undefined, increment(7)))
           .to.deep.equal({
-            counter: 10
+            counter: 7
           });
       });
     });
   });
 
   describe('map of handlers form', () => {
+    it('should throw an error if defaultState is not specified', () => {
+      expect(() => {
+        handleAction(type, { next: () => null });
+      })
+      .to.throw(
+        Error,
+        'defaultState for reducer handling TYPE should be defined'
+      );
+    });
+
     describe('resulting reducer', () => {
       it('returns previous state if type does not match', () => {
-        const reducer = handleAction('NOTTYPE', { next: () => null });
+        const reducer = handleAction('NOTTYPE', { next: () => null }, defaultState);
         expect(reducer(prevState, { type })).to.equal(prevState);
       });
 
@@ -100,7 +121,7 @@ describe('handleAction()', () => {
           next: (state, action) => ({
             counter: state.counter + action.payload
           })
-        });
+        }, defaultState);
         expect(reducer(prevState, { type, payload: 7 }))
           .to.deep.equal({
             counter: 10
@@ -112,7 +133,7 @@ describe('handleAction()', () => {
           throw: (state, action) => ({
             counter: state.counter + action.payload
           })
-        });
+        }, defaultState);
 
         expect(reducer(prevState, { type, payload: 7, error: true }))
           .to.deep.equal({
@@ -121,7 +142,7 @@ describe('handleAction()', () => {
       });
 
       it('returns previous state if matching handler is not function', () => {
-        const reducer = handleAction(type, { next: null, error: 123 });
+        const reducer = handleAction(type, { next: null, error: 123 }, defaultState);
         expect(reducer(prevState, { type, payload: 123 })).to.equal(prevState);
         expect(reducer(prevState, { type, payload: 123, error: true }))
           .to.equal(prevState);
@@ -134,7 +155,8 @@ describe('handleAction()', () => {
       const action1 = createAction('ACTION_1');
       const reducer = handleAction(
         combineActions(action1, 'ACTION_2', 'ACTION_3'),
-        (state, { payload }) => ({ ...state, number: state.number + payload })
+        (state, { payload }) => ({ ...state, number: state.number + payload }),
+        defaultState
       );
 
       expect(reducer({ number: 1 }, action1(1))).to.deep.equal({ number: 2 });
@@ -148,7 +170,7 @@ describe('handleAction()', () => {
         next(state, { payload }) {
           return { ...state, number: state.number + payload };
         }
-      });
+      }, defaultState);
 
       expect(reducer({ number: 1 }, action1(1))).to.deep.equal({ number: 2 });
       expect(reducer({ number: 1 }, { type: 'ACTION_2', payload: 2 })).to.deep.equal({ number: 3 });
@@ -165,7 +187,7 @@ describe('handleAction()', () => {
         throw(state) {
           return { ...state, threw: true };
         }
-      });
+      }, defaultState);
       const error = new Error;
 
       expect(reducer({ number: 0 }, action1(error)))
@@ -180,6 +202,7 @@ describe('handleAction()', () => {
       const reducer = handleAction(
         combineActions('ACTION_1', 'ACTION_2'),
         (state, { payload }) => ({ ...state, state: state.number + payload }),
+        defaultState
       );
 
       const state = { number: 0 };
@@ -191,11 +214,11 @@ describe('handleAction()', () => {
       const reducer = handleAction(
         combineActions('INCREMENT', 'DECREMENT'),
         (state, { payload }) => ({ ...state, counter: state.counter + payload }),
-        { counter: 10 }
+        defaultState
       );
 
-      expect(reducer(undefined, { type: 'INCREMENT', payload: +1 })).to.deep.equal({ counter: 11 });
-      expect(reducer(undefined, { type: 'DECREMENT', payload: -1 })).to.deep.equal({ counter: 9 });
+      expect(reducer(undefined, { type: 'INCREMENT', payload: +1 })).to.deep.equal({ counter: +1 });
+      expect(reducer(undefined, { type: 'DECREMENT', payload: -1 })).to.deep.equal({ counter: -1 });
     });
 
     it('should handle combined actions with symbols', () => {
@@ -204,7 +227,8 @@ describe('handleAction()', () => {
       const action3 = createAction(Symbol('ACTION_3'));
       const reducer = handleAction(
         combineActions(action1, action2, action3),
-        (state, { payload }) => ({ ...state, number: state.number + payload })
+        (state, { payload }) => ({ ...state, number: state.number + payload }),
+        defaultState
       );
 
       expect(reducer({ number: 0 }, action1(1)))
@@ -215,4 +239,36 @@ describe('handleAction()', () => {
         .to.deep.equal({ number: 3 });
     });
   });
+
+  describe('with invalid actions', () => {
+    it('should throw a descriptive error when the action object is missing', () => {
+      const reducer = handleAction(createAction('ACTION_1'), identity, {});
+      expect(
+        () => reducer(undefined)
+      ).to.throw(
+        Error,
+        'The FSA spec mandates an action object with a type. Try using the createAction(s) method.'
+      );
+    });
+
+    it('should throw a descriptive error when the action type is missing', () => {
+      const reducer = handleAction(createAction('ACTION_1'), identity, {});
+      expect(
+        () => reducer(undefined, {})
+      ).to.throw(
+        Error,
+        'The FSA spec mandates an action object with a type. Try using the createAction(s) method.'
+      );
+    });
+
+    it('should throw a descriptive error when the action type is not a string or symbol', () => {
+      const reducer = handleAction(createAction('ACTION_1'), identity, {});
+      expect(
+        () => reducer(undefined, { type: false })
+      ).to.throw(
+        Error,
+        'The FSA spec mandates an action object with a type. Try using the createAction(s) method.'
+      );
+    });
+  });
 });