Merge branch 'release/v1.0.5'

Author: Antoine Jaussoin

.gitignore

@@ -37,4 +37,4 @@ jspm_packages
 .node_repl_history
 .npmrc
 .yarnrc
-.vscode
+.vscode

.vscode/temp.sql

@@ -102,6 +102,7 @@ This examples is now actually using the `redux-saga` utility functions.
 
 The important point to note here, is that Sagas **describe** what happens, and don't actually act on it.
 For example, an API will never be called, you don't have to mock it, when using `call`.
+Same thing for a selector, you don't need to mock the state when using `yield select(mySelector)`.
 
 This makes testing very easy indeed.
 
@@ -146,25 +147,29 @@ describe('When testing a very simple Saga', () => {
 
 ## Testing a complex Saga
 
-This example deals with pretty much all use-cases for using Sagas, which involves calling an API, getting exceptions, and have some conditional logic based on some inputs.
+This example deals with pretty much all use-cases for using Sagas, which involves using a `select`or, `call`ing an API, getting exceptions, have some conditional logic based on some inputs and `put`ing new actions.
 
 ```javascript
 import sagaHelper from 'redux-saga-testing';
-import { call, put } from 'redux-saga/effects';
+import { call, put, select } from 'redux-saga/effects';
 
 const splitApi = jest.fn();
 const someActionSuccess = payload => ({ type: 'SOME_ACTION_SUCCESS', payload });
 const someActionEmpty = () => ({ type: 'SOME_ACTION_EMPTY' });
 const someActionError = error => ({ type: 'SOME_ACTION_ERROR', payload: error });
+const selectFilters = state => state.filters;
 
 function* mySaga(input) {
     try {
+        // We get the filters list from the state, using "select"
+        const filters = yield select(selectFilters);
+
         // We try to call the API, with the given input
         // We expect this API takes a string and returns an array of all the words, split by comma
         const someData = yield call(splitApi, input);
 
         // From the data we get from the API, we filter out the words 'foo' and 'bar'
-        const transformedData = someData.filter(w => ['foo', 'bar'].indexOf(w) === -1);
+        const transformedData = someData.filter(w => filters.indexOf(w) === -1);
 
         // If the resulting array is empty, we call the empty action, otherwise we call the success action
         if (transformedData.length === 0) {
@@ -184,6 +189,14 @@ describe('When testing a complex Saga', () => {
     describe('Scenario 1: When the input contains other words than foo and bar and doesn\'t throw', () => {
         const it = sagaHelper(mySaga('hello,foo,bar,world'));
 
+        it('should get the list of filters from the state', result => {
+            expect(result).toEqual(select(selectFilters));
+
+            // Here we specify what the selector should have returned.
+            // The selector is not called so we have to give its expected return value.
+            return ['foo', 'bar'];
+        });
+
         it('should have called the mock API first, which we are going to specify the results of', result => {
             expect(result).toEqual(call(splitApi, 'hello,foo,bar,world'));
 
@@ -204,6 +217,11 @@ describe('When testing a complex Saga', () => {
     describe('Scenario 2: When the input only contains foo and bar', () => {
         const it = sagaHelper(mySaga('foo,bar'));
 
+        it('should get the list of filters from the state', result => {
+            expect(result).toEqual(select(selectFilters));
+            return ['foo', 'bar'];
+        });
+
         it('should have called the mock API first, which we are going to specify the results of', result => {
             expect(result).toEqual(call(splitApi, 'foo,bar'));
             return ['foo', 'bar'];
@@ -221,6 +239,11 @@ describe('When testing a complex Saga', () => {
     describe('Scenario 3: The API is broken and throws an exception', () => {
         const it = sagaHelper(mySaga('hello,foo,bar,world'));
 
+        it('should get the list of filters from the state', result => {
+            expect(result).toEqual(select(selectFilters));
+            return ['foo', 'bar'];
+        });
+
         it('should have called the mock API first, which will throw an exception', result => {
             expect(result).toEqual(call(splitApi, 'hello,foo,bar,world'));
 
@@ -249,7 +272,7 @@ You have other examples in the [various](https://github.com/antoinejaussoin/redu
 
 ## FAQ
 
-- How can I test a Saga that uses `take` or `takeEvery`?
+#### How can I test a Saga that uses `take` or `takeEvery`?
 
 You should separate this generator in two: one that only uses `take` or `takeEvery` (the "watchers"), and the ones that atually run the code when the wait is over, like so:
 
@@ -278,6 +301,11 @@ export default function* rootSaga() {
 
 From the previous example, you don't have to test `rootSaga` but you can test `onSomeAction` and `onAnotherAction`.
 
+#### Do I need to mock the store and/or the state?
+
+No you don't. If you read the examples above carefuly, you'll notice that the actual selector (for example) is never called. That means you don't need to mock anything, just return the value your selector should have returned.
+This library is to test a saga *workflow*, not about testing your actual *selectors*. If you need to test a selector, do it in isolation (it's just a pure function after all).
+
 
 ## Code coverage
 
@@ -287,6 +315,10 @@ In the GitHub repo, you'll find examples using **Istanbul** (for Mocha) and **Je
 
 ## Change Log
 
+### v1.0.5
+ - Updating dependencies
+ - Adding examples using `selector`s (thanks [@TAGC](https://github.com/tagc) for the suggestion)
+
 ### v1.0.4
 
 - Updating dependencies

README.md

@@ -0,0 +1,29 @@
+import sagaHelper from '../main';
+import { call, select, put } from 'redux-saga/effects';
+import testAva from 'ava';
+
+const loginAction = payload => ({ type: 'LOGIN', payload });
+const selectUsername = state => state.foo;
+
+function* loginSaga() {
+    const username = yield select(selectUsername);
+    yield put(loginAction(username));
+}
+
+const test = sagaHelper(loginSaga(), testAva);
+
+test('should select the current username from the state', (result, t) => {
+    // Remember, we are not testing the selector here, just testing that the "select" function was called with a given selector function
+    // The selector won't be executed (and it can't anyway, there is no state known to redux-saga on this test)
+    t.deepEqual(result, select(selectUsername));
+    // We return what the selector should have returned
+    return 'donald.drumpf';
+});
+
+test('should trigger the login action with the username we got from the state', (result, t) => {
+    t.deepEqual(result, put(loginAction('donald.drumpf')));
+});
+
+test('and then nothing', (result, t) => {
+    t.is(result, undefined);
+});

ava/06.saga-using-selectors.test.js

@@ -1,21 +1,25 @@
 import sagaHelper from '../main';
-import { call, put } from 'redux-saga/effects';
+import { call, put, select } from 'redux-saga/effects';
 import testAva from 'ava';
 import sinon from 'sinon';
 
 const splitApi = sinon.spy();
 const someActionSuccess = payload => ({ type: 'SOME_ACTION_SUCCESS', payload });
 const someActionEmpty = () => ({ type: 'SOME_ACTION_EMPTY' });
 const someActionError = error => ({ type: 'SOME_ACTION_ERROR', payload: error });
+const selectFilters = state => state.filters;
 
 function* mySaga(input) {
     try {
+        // We get the filters list from the state, using "select"
+        const filters = yield select(selectFilters);
+
         // We try to call the API, with the given input
         // We expect this API takes a string and returns an array of all the words, split by comma
         const someData = yield call(splitApi, input);
 
-        // From the data we get from the API, we filter out the words 'foo' and 'bar'
-        const transformedData = someData.filter(w => ['foo', 'bar'].indexOf(w) === -1);
+        // From the data we get from the API, we filter out the words 'foo' and 'bar' (from the list of filters we got from the state)
+        const transformedData = someData.filter(w => filters.indexOf(w) === -1);
 
         // If the resulting array is empty, we call the empty action, otherwise we call the success action
         if (transformedData.length === 0) {
@@ -33,6 +37,14 @@ function* mySaga(input) {
 // Scenario 1: When the input contains other words than foo and bar and doesn\'t throw
 let test = sagaHelper(mySaga('hello,foo,bar,world'), testAva);
 
+test('should get the list of filters from the state', (result, t) => {
+    t.deepEqual(result, select(selectFilters));
+
+    // Here we specify what the selector should have returned.
+    // The selector is not called so we have to give its expected return value.
+    return ['foo', 'bar'];
+});
+
 test('should have called the mock API first, which we are going to specify the results of', (result, t) => {
     t.deepEqual(result, call(splitApi, 'hello,foo,bar,world'));
 
@@ -53,6 +65,11 @@ test('and then nothing', (result, t) => {
 // Scenario 2: When the input only contains foo and bar
 test = sagaHelper(mySaga('foo,bar'), testAva);
 
+test('should get the list of filters from the state', (result, t) => {
+    t.deepEqual(result, select(selectFilters));
+    return ['foo', 'bar'];
+});
+
 test('should have called the mock API first, which we are going to specify the results of', (result, t) => {
     t.deepEqual(result, call(splitApi, 'foo,bar'));
     return ['foo', 'bar'];
@@ -70,6 +87,11 @@ test('and then nothing', (result, t) => {
 // Scenario 3: The API is broken and throws an exception
 test = sagaHelper(mySaga('hello,foo,bar,world'), testAva);
 
+test('should get the list of filters from the state', (result, t) => {
+    t.deepEqual(result, select(selectFilters));
+    return ['foo', 'bar'];
+});
+
 test('should have called the mock API first, which will throw an exception', (result, t) => {
     t.deepEqual(result, call(splitApi, 'hello,foo,bar,world'));
 

ava/10.all-in-one-example.test.js

@@ -0,0 +1,30 @@
+import sagaHelper from '../main';
+import { call, select, put } from 'redux-saga/effects';
+
+const loginAction = payload => ({ type: 'LOGIN', payload });
+const selectUsername = state => state.foo;
+
+function* loginSaga() {
+    const username = yield select(selectUsername);
+    yield put(loginAction(username));
+}
+
+describe('When testing Saga that has a selector (fake login workflow)', () => {
+    const it = sagaHelper(loginSaga());
+
+    it('should select the current username from the state', result => {
+        // Remember, we are not testing the selector here, just testing that the "select" function was called with a given selector function
+        // The selector won't be executed (and it can't anyway, there is no state known to redux-saga on this test)
+        expect(result).toEqual(select(selectUsername));
+        // We return what the selector should have returned
+        return 'donald.drumpf';
+    });
+
+    it('should trigger the login action with the username we got from the state', result => {
+        expect(result).toEqual(put(loginAction('donald.drumpf')));
+    });
+
+    it('and then nothing', result => {
+        expect(result).toBeUndefined();
+    });
+});

jest/06.saga-using-selectors.spec.js

@@ -1,19 +1,23 @@
 import sagaHelper from '../main';
-import { call, put } from 'redux-saga/effects';
+import { call, put, select } from 'redux-saga/effects';
 
 const splitApi = jest.fn();
 const someActionSuccess = payload => ({ type: 'SOME_ACTION_SUCCESS', payload });
 const someActionEmpty = () => ({ type: 'SOME_ACTION_EMPTY' });
 const someActionError = error => ({ type: 'SOME_ACTION_ERROR', payload: error });
+const selectFilters = state => state.filters;
 
 function* mySaga(input) {
     try {
+        // We get the filters list from the state, using "select"
+        const filters = yield select(selectFilters);
+
         // We try to call the API, with the given input
         // We expect this API takes a string and returns an array of all the words, split by comma
         const someData = yield call(splitApi, input);
 
         // From the data we get from the API, we filter out the words 'foo' and 'bar'
-        const transformedData = someData.filter(w => ['foo', 'bar'].indexOf(w) === -1);
+        const transformedData = someData.filter(w => filters.indexOf(w) === -1);
 
         // If the resulting array is empty, we call the empty action, otherwise we call the success action
         if (transformedData.length === 0) {
@@ -33,6 +37,14 @@ describe('When testing a complex Saga', () => {
     describe('Scenario 1: When the input contains other words than foo and bar and doesn\'t throw', () => {
         const it = sagaHelper(mySaga('hello,foo,bar,world'));
 
+        it('should get the list of filters from the state', result => {
+            expect(result).toEqual(select(selectFilters));
+
+            // Here we specify what the selector should have returned.
+            // The selector is not called so we have to give its expected return value.
+            return ['foo', 'bar'];
+        });
+
         it('should have called the mock API first, which we are going to specify the results of', result => {
             expect(result).toEqual(call(splitApi, 'hello,foo,bar,world'));
 
@@ -53,6 +65,11 @@ describe('When testing a complex Saga', () => {
     describe('Scenario 2: When the input only contains foo and bar', () => {
         const it = sagaHelper(mySaga('foo,bar'));
 
+        it('should get the list of filters from the state', result => {
+            expect(result).toEqual(select(selectFilters));
+            return ['foo', 'bar'];
+        });
+
         it('should have called the mock API first, which we are going to specify the results of', result => {
             expect(result).toEqual(call(splitApi, 'foo,bar'));
             return ['foo', 'bar'];
@@ -70,6 +87,11 @@ describe('When testing a complex Saga', () => {
     describe('Scenario 3: The API is broken and throws an exception', () => {
         const it = sagaHelper(mySaga('hello,foo,bar,world'));
 
+        it('should get the list of filters from the state', result => {
+            expect(result).toEqual(select(selectFilters));
+            return ['foo', 'bar'];
+        });
+
         it('should have called the mock API first, which will throw an exception', result => {
             expect(result).toEqual(call(splitApi, 'hello,foo,bar,world'));
 

jest/10.all-in-one-example.spec.js

@@ -0,0 +1,31 @@
+import sagaHelper from '../main';
+import { call, select, put } from 'redux-saga/effects';
+import expect from 'expect.js';
+
+const loginAction = payload => ({ type: 'LOGIN', payload });
+const selectUsername = state => state.foo;
+
+function* loginSaga() {
+    const username = yield select(selectUsername);
+    yield put(loginAction(username));
+}
+
+describe('When testing Saga that has a selector (fake login workflow)', () => {
+    const it = sagaHelper(loginSaga());
+
+    it('should select the current username from the state', result => {
+        // Remember, we are not testing the selector here, just testing that the "select" function was called with a given selector function
+        // The selector won't be executed (and it can't anyway, there is no state known to redux-saga on this test)
+        expect(result).to.eql(select(selectUsername));
+        // We return what the selector should have returned
+        return 'donald.drumpf';
+    });
+
+    it('should trigger the login action with the username we got from the state', result => {
+        expect(result).to.eql(put(loginAction('donald.drumpf')));
+    });
+
+    it('and then nothing', result => {
+        expect(result).to.be(undefined);
+    });
+});