Testing Reducers

Luckily, testing reducers is a lot like testing our synchronous action creators, since all reducer operations are synchronous. This plays a big role in making our global state easy to keep track of, which is why we're big fans of Redux.

We'll test the counter reducer in angular2-redux-starter, as follows:

  1. export default function counter(state = 0, action)
  2.   switch (action.type) {
  3.     case INCREMENT_COUNTER:
  4.       return state + 1;
  5.     case DECREMENT_COUNTER:
  6.       return state - 1;
  7.     default:
  8.       return state;
  9.   }
  10. }

As you can see, there are three cases to test: the default case, the increment and the decrement. We want to test that our actions trigger the state changes we expect from the reducer.

  1. import { INCREMENT_COUNTER, DECREMENT_COUNTER } from '../actions/counter';
  2. import counter from './counter';                                         
  4. describe('counter reducers', () => {                                     
  5.   it('should handle initial state', () => {                              
  6.     expect(                                                         
  7.       counter(undefined, {})                                             
  8.     )                                                                    
  9.     .toEqual(0)                                                         
  10.   });                                                                    
  12.   it('should handle INCREMENT_COUNTER', () => {                          
  13.     expect(                                                         
  14.       counter(0, {                                                       
  15.         type: INCREMENT_COUNTER                                          
  16.       })                                                                 
  17.     )                                                                    
  18.     .toEqual(1)                                                         
  19.   });                                                                    
  21.   it('should handle DECREMENT_COUNTER', () => {                          
  22.     expect(                                                         
  23.       counter(1, {                                                       
  24.         type: DECREMENT_COUNTER                                          
  25.       })                                                                 
  26.     )                                                                    
  27.     .toEqual(0)                                                         
  28.   });                                                                    
  29. });

Note that we're only testing the section of Redux state that the counter reducer is responsible for, and not the whole.We can see from these tests that Redux is largely built on pure functions.

原文: https://angular-2-training-book.rangle.io/handout/testing/redux/reducers.html