Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/mitodl/redux-asserts


https://github.com/mitodl/redux-asserts

Last synced: 6 days ago
JSON representation

Awesome Lists containing this project

README 

        
## redux-asserts

Functions to assert dispatched actions in redux. These functions are aimed at making

integration testing with redux easier by abstracting away the need to manage and listen to the store's

actions.



## How it works

A redux store is created with a wrapper that listens for actions dispatched to it. The assert functions

return a `Promise` which resolves when all expected action types are received, or rejects when an unexpected

action type is received.



## Installation



`npm install redux-asserts --save-dev`



## Tests

Check out the repository, run `npm install`, then run `npm test`.



## Usage

In your testing code:



    import configureTestStore from 'redux-asserts';

    import rootReducer from '../reducers';



Create a redux store for testing using `configureTestStore`. Then use that

store's `createListenForActions` and `createListenForActions` functions to

create the `listenForActions` and `dispatchThen` functions respectively.



### listenForActions



Asserts that a list of actions were called during or after the execution of the callback,

then resolves the `Promise`. The `Promise` will reject on an assertion error, but

note that there are cases where the `Promise` may resolve earlier than the user would want,

or the `Promise` may never be resolved or rejected.



This function takes two required arguments:



    listenForActions(actionTypes, callback) => Promise



- actionTypes: A list of action types to assert. This list must match exactly

the types that are dispatched to the store , but the types may be

in any order. If there are more action types being expected than actions, the

`Promise` may never resolve. If there are fewer action types, the `Promise` will

resolve since all expected action types were asserted. If at any point there is

an unexpected action type the `Promise` will reject.

- callback: A function to be executed right after the store starts listening

for actions to be asserted. Note that the actions don't need to be dispatched

within this function specifically. The store will keep listening until all

expected actions are received, or until there is one unexpected action.

- return value: A `Promise` which will be resolved or rejected after the

action types are asserted.



Example:



    describe('cart rendering', () => {

      let listenForActions, store;

      beforeEach(() => {

        store = configureTestStore(rootReducer);

        listenForActions = store.createListenForActions();

      });



      it('clicks the add to cart button', done => {

        listenForActions([UPDATE_CART_ITEMS, UPDATE_CART_VISIBILITY], () => {

          // Click the Update cart button

          let button = TestUtils.findRenderedDOMComponentWithClass(component, "add-to-cart");

          TestUtils.Simulate.click(button);

        }).then(state => {

          done();

        });

      });

    });



This runs the function passed into `listenForActions`, then waits while

asserting the types dispatched. If the types are asserted

to be dispatched, the promise resolves.



See also the examples in the test directory.



### dispatchThen



Dispatches an action or action creator, then asserts a list of action types were called

after the dispatch of the action, then resolves the `Promise`. The `Promise` will

reject on an assertion error, but there are cases where the `Promise`

may resolve earlier than the user would want, or the `Promise` may never be resolved or rejected.



Note that this function is exactly the same as `listenForActions` but where the callback is



    dispatch(action());



This function takes two required arguments:



    dispatchThen(action, actionTypes) => Promise



- action: The action or action creator, whatever you would pass to `dispatch()`.

- actionTypes: A list of action types to assert. This list must match exactly

the types that are dispatched to the store by `action`, but the types may be

in any order. If there are more action types being expected than actions, the

`Promise` may never resolve. If there are fewer action types, the `Promise` will

resolve since all expected action types were asserted. If at any point there is

an unexpected action type the `Promise` will reject.

- return value: A `Promise` which will be resolved or rejected after the

action types are asserted.



Example:



    describe('course reducers', () => {

      let dispatchThen, store;

      beforeEach(() => {

        // Create a redux store for testing

        store = configureTestStore(rootReducer);

        // Create the dispatchThen function we use below

        dispatchThen = store.createDispatchThen(state => state.courseList);

      });

  

      it('should fetch a list of courses successfully', done => {

        dispatchThen(fetchCourseList(), [REQUEST_COURSE_LIST, RECEIVE_COURSE_LIST_SUCCESS]).then(courseState => {

          assert.deepEqual(courseState.courseList, COURSE_LIST_DATA);

          assert.equal(courseState.courseListStatus, FETCH_SUCCESS);

  

          done();

        });

      });

    });



This dispatches the `fetchCourseList` action, asserts that the two action

types `REQUEST_COURSE_LIST` and `RECEIVE_COURSE_LIST_SUCCESS` were the only

actions dispatched, then the promise resolves with the given state.



See also the examples in the test directory.