Add handler tests

Author: dpikt

docs.md

@@ -358,12 +358,12 @@ Returns **[Object][20]** An [LP_API] action that can be handled by the lp-redux-
 
 This library exports the following selectors for determining the status of requests:
 
--   `selectors.status(state, requestKey, [slice])`
--   `selectors.hasStatus(state, requestKey, [slice])`
--   `selectors.isLoading(state, requestKey, [slice])`
--   `selectors.isComplete(state, requestKey, [slice])`
--   `selectors.isSuccess(state, requestKey, [slice])`
--   `selectors.isFailure(state, requestKey, [slice])`
+-   `selectors.status(state, requestAction, [slice])`
+-   `selectors.hasStatus(state, requestAction, [slice])`
+-   `selectors.isLoading(state, requestAction, [slice])`
+-   `selectors.isComplete(state, requestAction, [slice])`
+-   `selectors.isSuccess(state, requestAction, [slice])`
+-   `selectors.isFailure(state, requestAction, [slice])`
 
 In order to work, the `lp-redux-api` reducer must be included in `combineReducers()`.
 Selectors expect the reducer to be keyed under `'api'`- if a different key is used,
@@ -389,12 +389,12 @@ combineReducers({
 
 // Now you can keep track of request status elsewhere in your app
 
-import { requestWithKey, selectors as apiSelectors } from 'lp-redux-api'
+import { createRequest, selectors as apiSelectors } from 'lp-redux-api'
 
-const REQ_FETCH_USERS = 'REQ_FETCH_USERS'
-dispatch(requestWithKey(REQ_FETCH_USERS, { url: '/users' }))
+const fetchUsers = createRequest('FETCH_USERS', { url: '/users' })
+dispatch(fetchUsers())
 
-apiSelectors.status(state, REQ_FETCH_USERS) // -> 'loading'
+apiSelectors.status(state, fetchUsers) // -> 'loading'
 
 *
 ```

src/create-request.js

@@ -1,4 +1,5 @@
 import LP_API from './LP_API'
+import { isObject, isFunction } from 'lodash'
 
 /**
  * A function that creates action creators for making API requests, much like [createAction](https://redux-actions.js.org/api-reference/createaction-s) from `redux-actions`.
@@ -26,13 +27,15 @@ import LP_API from './LP_API'
 **/
 
 function createActionOptions (definition, args) {
-  if (typeof definition === 'object') return definition
-  if (typeof definition === 'function') return definition(...args) || {}
-  throw new Error('Request definition must be an object or a function.')
+  return isFunction(definition)
+    ? definition(...args) || {}
+    : definition
 }
 
 function createRequest (type, definition) {
   if (!type) throw new Error('Must include a type for your request.')
+  if (!definition) throw new Error('Must include a request definition for your request.')
+  if (!(isObject(definition) || isFunction(definition))) throw new Error('Request definition must be an object or a function.')
   function actionCreator (...args) {
     return {
       [LP_API]: {

src/handlers/handle-response.js

@@ -26,6 +26,7 @@ import { isSuccessAction, isFailureAction } from './helpers'
 **/
 
 function handleResponse (successHandler, failureHandler) {
+  if (!(successHandler && failureHandler)) throw new Error('handleResponse requires both a success handler and failure handler.')
   return (state, action) => {
     if (isSuccessAction(action)) return successHandler(state, action)
     if (isFailureAction(action)) return failureHandler(state, action)

src/selectors.js

@@ -7,12 +7,12 @@ import {
 
 /**
  * This library exports the following selectors for determining the status of requests:
- * - `selectors.status(state, requestKey, [slice])`
- * - `selectors.hasStatus(state, requestKey, [slice])`
- * - `selectors.isLoading(state, requestKey, [slice])`
- * - `selectors.isComplete(state, requestKey, [slice])`
- * - `selectors.isSuccess(state, requestKey, [slice])`
- * - `selectors.isFailure(state, requestKey, [slice])`
+ * - `selectors.status(state, requestAction, [slice])`
+ * - `selectors.hasStatus(state, requestAction, [slice])`
+ * - `selectors.isLoading(state, requestAction, [slice])`
+ * - `selectors.isComplete(state, requestAction, [slice])`
+ * - `selectors.isSuccess(state, requestAction, [slice])`
+ * - `selectors.isFailure(state, requestAction, [slice])`
  * 
  * In order to work, the `lp-redux-api` reducer must be included in `combineReducers()`.
  * Selectors expect the reducer to be keyed under `'api'`- if a different key is used,
@@ -38,12 +38,12 @@ import {
  * 
  * // Now you can keep track of request status elsewhere in your app
  * 
- * import { requestWithKey, selectors as apiSelectors } from 'lp-redux-api'
+ * import { createRequest, selectors as apiSelectors } from 'lp-redux-api'
  * 
- * const REQ_FETCH_USERS = 'REQ_FETCH_USERS'
- * dispatch(requestWithKey(REQ_FETCH_USERS, { url: '/users' }))
+ * const fetchUsers = createRequest('FETCH_USERS', { url: '/users' })
+ * dispatch(fetchUsers())
  * 
- * apiSelectors.status(state, REQ_FETCH_USERS) // -> 'loading'
+ * apiSelectors.status(state, fetchUsers) // -> 'loading'
  *
 **/
 

test/create-request.test.js

@@ -0,0 +1,29 @@
+import { createRequest, LP_API } from '../src/'
+import { REQUEST_TYPE } from './fixtures'
+
+test('createRequest requires a type argument', () => {
+  expect(createRequest).toThrow()
+})
+
+test('createRequest requires a definition argument', () => {
+  expect(() => createRequest(REQUEST_TYPE)).toThrow()
+})
+
+test('createRequest accepts object request definitions', () => {
+  const options = { foo: 'bar' }
+  const actionCreator = createRequest(REQUEST_TYPE, options)
+  const action = actionCreator()
+  expect(action[LP_API]).toEqual({ requestKey: REQUEST_TYPE, foo: 'bar' })
+})
+
+test('createRequest accepts function request definitions', () => {
+  const actionCreator = createRequest(REQUEST_TYPE, (arg) => ({
+    foo: arg
+  }))
+  const action = actionCreator('bar')
+  expect(action[LP_API]).toEqual({ requestKey: REQUEST_TYPE, foo: 'bar' })
+})
+
+test('createRequest rejects other types of request definitions', () => {
+  expect(() => createRequest(REQUEST_TYPE, 'wtf')).toThrow()
+})

test/fixtures.js

@@ -3,6 +3,7 @@
 import { LP_API } from '../src'
 
 export const REQUEST_KEY = 'REQUEST_KEY'
+export const REQUEST_TYPE = 'REQUEST_TYPE'
 export const ACTION_TYPE_REQUEST = 'ACTION_TYPE_REQUEST'
 export const ACTION_TYPE_SUCCESS = 'ACTION_TYPE_SUCCESS'
 export const ACTION_TYPE_FAILURE = 'ACTION_TYPE_FAILURE'

test/handlers/handle-failure.test.js

@@ -0,0 +1,22 @@
+import { handleFailure, LP_API_STATUS_FAILURE, LP_API_STATUS_SUCCESS } from '../../src/'
+
+const STATE = { foo: 'bar' }
+const REQUEST_TYPE = 'FETCH_USERS'
+const FAILURE_ACTION = { type: REQUEST_TYPE, payload: { status: LP_API_STATUS_FAILURE }}
+const SUCCESS_ACTION = { type: REQUEST_TYPE, payload: { status: LP_API_STATUS_SUCCESS }}
+
+test('handleFailure runs handler with state and action when request fails', () => {
+  const NEW_STATE = { new: 'state' }
+  const handler = jest.fn(() => NEW_STATE)
+  const failureHandler = handleFailure(handler)
+  const newState = failureHandler(STATE, FAILURE_ACTION)
+  expect(handler).toHaveBeenCalledWith(STATE, FAILURE_ACTION)
+  expect(newState).toEqual(NEW_STATE)
+})
+
+test('handleFailure returns state when request does not fail', () => {
+  const handler = jest.fn()
+  const failureHandler = handleFailure(handler)
+  const newState = failureHandler(STATE, SUCCESS_ACTION)
+  expect(newState).toEqual(STATE)
+})

test/handlers/handle-response.test.js

@@ -0,0 +1,35 @@
+import { handleResponse, LP_API_STATUS_FAILURE, LP_API_STATUS_SUCCESS } from '../../src/'
+
+const STATE = { foo: 'bar' }
+const REQUEST_TYPE = 'FETCH_USERS'
+const FAILURE_ACTION = { type: REQUEST_TYPE, payload: { status: LP_API_STATUS_FAILURE }}
+const SUCCESS_ACTION = { type: REQUEST_TYPE, payload: { status: LP_API_STATUS_SUCCESS }}
+
+test('handleResponse requires two handlers', () => {
+  const successHandler = jest.fn()
+  const failureHandler = jest.fn()
+  expect(() => handleResponse(successHandler)).toThrow()
+  expect(() => handleResponse(null, failureHandler)).toThrow()
+})
+
+test('handleResponse runs success handler with state and action when request succeeds', () => {
+  const SUCCESS_STATE = { success: 'state' }
+  const FAILURE_STATE = { failure: 'state' }
+  const successHandler = jest.fn(() => SUCCESS_STATE)
+  const failureHandler = jest.fn(() => FAILURE_STATE)
+  const handler = handleResponse(successHandler, failureHandler)
+  const newState = handler(STATE, SUCCESS_ACTION)
+  expect(successHandler).toHaveBeenCalledWith(STATE, SUCCESS_ACTION)
+  expect(newState).toEqual(SUCCESS_STATE)
+})
+
+test('handleResponse runs failure handler with state and action when request fails', () => {
+  const SUCCESS_STATE = { success: 'state' }
+  const FAILURE_STATE = { failure: 'state' }
+  const successHandler = jest.fn(() => SUCCESS_STATE)
+  const failureHandler = jest.fn(() => FAILURE_STATE)
+  const handler = handleResponse(successHandler, failureHandler)
+  const newState = handler(STATE, FAILURE_ACTION)
+  expect(failureHandler).toHaveBeenCalledWith(STATE, FAILURE_ACTION)
+  expect(newState).toEqual(FAILURE_STATE)
+})

test/handlers/handle-success.test.js

@@ -0,0 +1,22 @@
+import { handleSuccess, LP_API_STATUS_FAILURE, LP_API_STATUS_SUCCESS } from '../../src/'
+
+const STATE = { foo: 'bar' }
+const REQUEST_TYPE = 'FETCH_USERS'
+const FAILURE_ACTION = { type: REQUEST_TYPE, payload: { status: LP_API_STATUS_FAILURE }}
+const SUCCESS_ACTION = { type: REQUEST_TYPE, payload: { status: LP_API_STATUS_SUCCESS }}
+
+test('handleSuccess runs handler with state and action when request succeeds', () => {
+  const NEW_STATE = { new: 'state' }
+  const handler = jest.fn(() => NEW_STATE)
+  const successHandler = handleSuccess(handler)
+  const newState = successHandler(STATE, SUCCESS_ACTION)
+  expect(handler).toHaveBeenCalledWith(STATE, SUCCESS_ACTION)
+  expect(newState).toEqual(NEW_STATE)
+})
+
+test('handleSuccess returns state when request does not succeed', () => {
+  const handler = jest.fn()
+  const successHandler = handleSuccess(handler)
+  const newState = successHandler(STATE, FAILURE_ACTION)
+  expect(newState).toEqual(STATE)
+})

test/handlers/index.js

@@ -0,0 +1,6 @@
+export handleSuccess from './handle-success'
+export handleFailure from './handle-failure'
+export handleResponse from './handle-response'
+export setOnSuccess from './set-on-success'
+export setOnFailure from './set-on-failure'
+export setOnResponse from './set-on-response'

test/handlers/set-on-failure.test.js

@@ -0,0 +1,28 @@
+import { setOnFailure, LP_API_STATUS_FAILURE, LP_API_STATUS_SUCCESS } from '../../src/'
+
+const STATE = { foo: 'bar' }
+const REQUEST_TYPE = 'FETCH_USERS'
+const ERROR_DATA = 'ERRRRRROR'
+const FAILURE_ACTION = { type: REQUEST_TYPE, payload: { status: LP_API_STATUS_FAILURE, data: ERROR_DATA }}
+const SUCCESS_ACTION = { type: REQUEST_TYPE, payload: { status: LP_API_STATUS_SUCCESS }}
+
+test('setOnFailure sets state with error info when request fails', () => {
+  const failureHandler = setOnFailure('errorPath')
+  const newState = failureHandler(STATE, FAILURE_ACTION)
+  expect(newState.errorPath).toEqual(ERROR_DATA)
+})
+
+test('setOnFailure can receive a transform function', () => {
+  const CUSTOM_DATA = 'custom stuff'
+  const transform = jest.fn(() => CUSTOM_DATA)
+  const failureHandler = setOnFailure('errorPath', transform)
+  const newState = failureHandler(STATE, FAILURE_ACTION)
+  expect(transform).toHaveBeenCalledWith(FAILURE_ACTION, STATE)
+  expect(newState.errorPath).toEqual(CUSTOM_DATA)
+})
+
+test('setOnFailure returns state when request does not fail', () => {
+  const failureHandler = setOnFailure('errorPath')
+  const newState = failureHandler(STATE, SUCCESS_ACTION)
+  expect(newState).toEqual(STATE)
+})

test/handlers/set-on-response.test.js

@@ -0,0 +1,38 @@
+import { setOnResponse, LP_API_STATUS_FAILURE, LP_API_STATUS_SUCCESS } from '../../src/'
+
+const STATE = { foo: 'bar' }
+const REQUEST_TYPE = 'FETCH_USERS'
+const ERROR_DATA = 'BAD!'
+const DATA = 'returned data'
+const FAILURE_ACTION = { type: REQUEST_TYPE, payload: { status: LP_API_STATUS_FAILURE, data: ERROR_DATA }}
+const SUCCESS_ACTION = { type: REQUEST_TYPE, payload: { status: LP_API_STATUS_SUCCESS, data: DATA }}
+
+test('setOnResponse sets state with data when request succeeds', () => {
+  const handler = setOnResponse('dataPath', 'errorPath')
+  const newState = handler(STATE, SUCCESS_ACTION)
+  expect(newState.dataPath).toEqual(DATA)
+})
+
+test('setOnResponse sets state with error data when request fails', () => {
+  const handler = setOnResponse('dataPath', 'errorPath')
+  const newState = handler(STATE, FAILURE_ACTION)
+  expect(newState.errorPath).toEqual(ERROR_DATA)
+})
+
+test('setOnResponse can receive a success transform function', () => {
+  const CUSTOM_DATA = 'custom stuff'
+  const transform = jest.fn(() => CUSTOM_DATA)
+  const handler = setOnResponse('dataPath', 'errorPath', transform)
+  const newState = handler(STATE, SUCCESS_ACTION)
+  expect(transform).toHaveBeenCalledWith(SUCCESS_ACTION, STATE)
+  expect(newState.dataPath).toEqual(CUSTOM_DATA)
+})
+
+test('setOnResponse can receive a failure transform function', () => {
+  const CUSTOM_DATA = 'custom stuff'
+  const transform = jest.fn(() => CUSTOM_DATA)
+  const handler = setOnResponse('dataPath', 'errorPath', null, transform)
+  const newState = handler(STATE, FAILURE_ACTION)
+  expect(transform).toHaveBeenCalledWith(FAILURE_ACTION, STATE)
+  expect(newState.errorPath).toEqual(CUSTOM_DATA)
+})

test/handlers/set-on-success.test.js

@@ -0,0 +1,28 @@
+import { setOnSuccess, LP_API_STATUS_FAILURE, LP_API_STATUS_SUCCESS } from '../../src/'
+
+const STATE = { foo: 'bar' }
+const REQUEST_TYPE = 'FETCH_USERS'
+const DATA = 'returned data'
+const FAILURE_ACTION = { type: REQUEST_TYPE, payload: { status: LP_API_STATUS_FAILURE }}
+const SUCCESS_ACTION = { type: REQUEST_TYPE, payload: { status: LP_API_STATUS_SUCCESS, data: DATA }}
+
+test('setOnSuccess sets state with data when request succeeds', () => {
+  const successHandler = setOnSuccess('dataPath')
+  const newState = successHandler(STATE, SUCCESS_ACTION)
+  expect(newState.dataPath).toEqual(DATA)
+})
+
+test('setOnSuccess can receive a transform function', () => {
+  const CUSTOM_DATA = 'custom stuff'
+  const transform = jest.fn(() => CUSTOM_DATA)
+  const successHandler = setOnSuccess('dataPath', transform)
+  const newState = successHandler(STATE, SUCCESS_ACTION)
+  expect(transform).toHaveBeenCalledWith(SUCCESS_ACTION, STATE)
+  expect(newState.dataPath).toEqual(CUSTOM_DATA)
+})
+
+test('setOnSuccess returns state when request does not succeed', () => {
+  const successHandler = setOnSuccess('dataPath')
+  const newState = successHandler(STATE, FAILURE_ACTION)
+  expect(newState).toEqual(STATE)
+})