fix(dev-mode): warn if non-functions are passed to createReducer etc.

fix #4

Author: jedwards1211

.eslintrc

@@ -1,5 +1,8 @@
 {
   "extends": [
     "@jedwards1211/eslint-config", "@jedwards1211/eslint-config-flow"
-  ]
+  ],
+  "globals": {
+    "process": false
+  }
 }

src/checkForNonFunctions.js

@@ -0,0 +1,11 @@
+import every from 'lodash.every'
+
+/* global console */
+
+export default function checkForNotFunctions(collection, name) {
+  if (!every(collection, r => r instanceof Function)) {
+    const error = new Error(name + ' should all be functions')
+    console.error(error.stack) // eslint-disable-line no-console
+  }
+}
+

src/composeMiddleware.js

@@ -2,11 +2,14 @@ import every from 'lodash.every'
 import forEach from 'lodash.foreach'
 import mapValues from 'lodash.mapvalues'
 import createMiddleware from './createMiddleware'
+import checkForNonFunctions from './checkForNonFunctions'
 
 export default function composeMiddleware(...middlewares) {
   if (middlewares.length === 0) return store => dispatch => dispatch
   if (middlewares.length === 1) return middlewares[0]
 
+  if (process.env.NODE_ENV !== 'production') checkForNonFunctions(middlewares, 'middlewares')
+
   if (every(middlewares, middleware => middleware.actionHandlers)) {
     // regroup all the action handlers in the middlewares by action type.
     let actionHandlers = {}

src/composeReducers.js

@@ -3,11 +3,14 @@ import every from 'lodash.every'
 import forEach from 'lodash.foreach'
 import mapValues from 'lodash.mapvalues'
 import createReducer from './createReducer'
+import checkForNonFunctions from './checkForNonFunctions'
 
 export default function composeReducers(...reducers) {
   if (reducers.length === 0) return state => state
   if (reducers.length === 1) return reducers[0]
 
+  if (process.env.NODE_ENV !== 'production') checkForNonFunctions(reducers, 'reducers')
+
   // if all reducers have actionHandlers maps, merge the maps using composeReducers
   if (every(reducers, reducer => reducer.actionHandlers instanceof Object)) {
     let actionHandlers = {}

src/createMiddleware.js

@@ -1,4 +1,8 @@
+import checkForNonFunctions from './checkForNonFunctions'
+
 export default function createMiddleware(actionHandlers) {
+  if (process.env.NODE_ENV !== 'production') checkForNonFunctions(actionHandlers, 'actionHandlers')
+
   const result = store => next => action => {
     const handler = actionHandlers[action.type]
     if (!handler) return next(action)

src/createPluggableMiddleware.js

@@ -1,4 +1,5 @@
 import memoize from 'lodash.memoize'
+import checkForNonFunctions from './checkForNonFunctions'
 
 /**
  * This is used for hot reloading redux middleware.
@@ -9,10 +10,15 @@ import memoize from 'lodash.memoize'
  * hmrMiddleware.replaceMiddleware(myNewMiddleware);
  */
 export default function createPluggableMiddleware(middleware) {
+  if (process.env.NODE_ENV !== 'production') checkForNonFunctions(middleware, 'middleware')
+
   const result = store => next => {
     const dispatch = memoize(middleware => middleware ? middleware(store)(next) : next)
     return action => dispatch(middleware)(action)
   }
-  result.replaceMiddleware = nextMiddleware => middleware = nextMiddleware
+  result.replaceMiddleware = nextMiddleware => {
+    if (process.env.NODE_ENV !== 'production') checkForNonFunctions(nextMiddleware, 'nextMiddleware')
+    middleware = nextMiddleware
+  }
   return result
 }

src/createReducer.js

@@ -1,11 +1,14 @@
 import size from 'lodash.size'
+import checkForNonFunctions from './checkForNonFunctions'
 
 export default function createReducer(initialState, actionHandlers) {
   if (arguments.length === 1) {
     actionHandlers = initialState
     initialState = undefined
   }
 
+  if (process.env.NODE_ENV !== 'production') checkForNonFunctions(actionHandlers, 'actionHandlers')
+
   let result
   if (size(actionHandlers)) {
     result = (state = initialState, action) => {

test/devWarningTest.js

@@ -0,0 +1,80 @@
+import {expect} from 'chai'
+import sinon from 'sinon'
+import createReducer from '../src/createReducer'
+import composeReducers from '../src/composeReducers'
+import createMiddleware from '../src/createMiddleware'
+import composeMiddleware from '../src/composeMiddleware'
+import createPluggableMiddleware from '../src/createPluggableMiddleware'
+
+/* eslint-disable no-console */
+/* eslint-env node */
+
+describe('dev mode warnings', () => {
+  let origNodeEnv
+  before(() => {
+    origNodeEnv = process.env.NODE_ENV
+    process.env.NODE_ENV = ''
+  })
+  after(() => process.env.NODE_ENV = origNodeEnv)
+  beforeEach(() => {
+    sinon.spy(console, 'error')
+  })
+  afterEach(() => {
+    console.error.restore()
+  })
+  describe('createReducer', () => {
+    it('warns if any actionHandlers are not functions', () => {
+      createReducer({hello: 'world'})
+      expect(console.error.called).to.be.true
+    })
+    it("doesn't warn if all actionHandlers are functions", () => {
+      createReducer({hello: () => 'world'})
+      expect(console.error.called).to.be.false
+    })
+  })
+  describe('composeReducers', () => {
+    it('warns if any reducers are not functions', () => {
+      composeReducers(() => {}, 'hello')
+      expect(console.error.called).to.be.true
+    })
+    it("doesn't warn if all actionHandlers are functions", () => {
+      composeReducers(() => {})
+      expect(console.error.called).to.be.false
+    })
+  })
+  describe('createMiddleware', () => {
+    it('warns if any actionHandlers are not functions', () => {
+      createMiddleware({hello: 'world'})
+      expect(console.error.called).to.be.true
+    })
+    it("doesn't warn if all actionHandlers are functions", () => {
+      createMiddleware({hello: () => 'world'})
+      expect(console.error.called).to.be.false
+    })
+  })
+  describe('composeMiddleware', () => {
+    it('warns if any reducers are not functions', () => {
+      composeMiddleware(() => {}, 'hello')
+      expect(console.error.called).to.be.true
+    })
+    it("doesn't warn if all actionHandlers are functions", () => {
+      composeMiddleware(() => {})
+      expect(console.error.called).to.be.false
+    })
+  })
+  describe('createPluggableMiddleware', () => {
+    it('warns if any reducers are not functions', () => {
+      const middleware = createPluggableMiddleware('hello')
+      expect(console.error.called).to.be.true
+      console.error.reset()
+      middleware.replaceMiddleware('world')
+      expect(console.error.called).to.be.true
+    })
+    it("doesn't warn if all actionHandlers are functions", () => {
+      const middleware = createPluggableMiddleware(() => {})
+      expect(console.error.called).to.be.false
+      middleware.replaceMiddleware(() => () => () => 'world')
+      expect(console.error.called).to.be.false
+    })
+  })
+})