Simplify testing of redux action and async action creators
Branch: master
Clone or download
Type Name Latest commit message Commit time
Failed to load latest commit information.
docs Update docs Jan 18, 2017
documentation Update docs Jan 18, 2017
src 1.3.0 Jan 18, 2017
test Add support for jest Jan 15, 2017
.babelrc Initial commit Apr 5, 2016
.eslintrc Use airbnb-base eslint config directly Apr 22, 2016
.gitignore Change folder structure. Use files for import instead of folders Apr 8, 2016
.travis.yml Initial commit Apr 5, 2016
LICENSE Initial commit Apr 5, 2016 Add support for jest Jan 15, 2017
package.json Split copy resources Jan 18, 2017


Assertions for redux actions testing.

This library adds assertions for redux actions testing.
It use redux-mock-store to mock redux store.

build status npm version

Supported Assertion Frameworks/Libraries:

If you have not found assertion framework/library that you are using - please add comment into this issue.

What it does:

Allows to avoid retesting nested action creators

It allows to test only actions that need to be tested.

We have two actions (A, B). Each one makes async http requests.
Action A makes a request and if the result is successful it triggers Action B.
Action B is also used as an independent action.
Action B can be tested separately.
Therefore, we don't need to test it again in Action A.


function actionA() {
  return dispatch => {
    return api.getA().then(response => {
      }).catch(err => {

function actionB() {
  return dispatch => {
    return api.getB().then(response => {
      }).catch(err => {


const expectedActions = [
  { type: action_a_start },
  { type: action_a_success },   
  { type: action_b_start }, // retesting of action B
  { type: action_b_success } // retesting of action B];
const store = mockStore({ todos: [] });
store.dispatch(actionA()).then(() => {


expect(actionA()).withState({ todos: [] }).toDispatch([
  { type: action_a_start },
  { type: action_a_success },
  actionB() // just executing tested action
], done);

Reduces repetitive code of test methods

It reduces boilerplate of test methods and makes testing fluent.


const store = mockStore(/* initial state */);
const expectedActions = [
  { type: types.FETCH_TODOS_REQUEST },
  /* All expected triggered action objects */
store.dispatch(fetchData()).then(() => {
  const actions = store.getActions();


const expectedActions = [
  /*All expected triggered action objects or action creator functions*/
expect(fetchData()).toDispatchActions(expectedActions, done);

With using customised store state:

expect(fetchData()).withState({/*custom state*/}).toDispatchActions(expectedActions, done);

Simplifies initial setup

It provides singe-time global configuration for middlewares and initial store state.


const middlewares = [thunk];
const mockStore = configureStore(middlewares);
const store = mockStore({ /*initial store object*});


registerMiddlewares([ thunk ]);
// to set custom initial state 
registerInitialStoreState(/*object of function*/);
// to generate initial state of your application
registerInitialStoreState(buildInitialStoreState(/*your root reducer*/));


Using npm:

$ npm install --save-dev redux-actions-assertions

Redux middlewares registration

// using ES6 modules
import { registerMiddlewares } from 'redux-actions-assertions';

// using CommonJS modules
var registerMiddlewares = require('redux-actions-assertions').registerMiddlewares;

// registration
  /* Here you need to list your middlewares */

Default initial store state registration

By using state object or function:

// using ES6 modules
import { registerInitialStoreState } from 'redux-actions-assertions';

// using CommonJS modules
var registerInitialStoreState = require('redux-actions-assertions').registerInitialStoreState;

// registration
registerInitialStoreState(/* default initial state object or function */);

By using your root reducer:

// using ES6 modules
import { buildInitialStoreState, registerInitialStoreState } from 'redux-actions-assertions';

// using CommonJS modules
var reduxActionsAssertions = require('redux-actions-assertions');
var registerInitialStoreState = reduxActionsAssertions.registerInitialStoreState;

// registration
registerInitialStoreState(buildInitialStoreState(/* root reducer function */));