Refactoring WIP

Author: Olajide

src/js/actions/proverbActions.js

@@ -3,61 +3,40 @@ import webAPI from '../utils/webAPI';
 import mockProverbApi from '../api/mockProverbsApi';
 
 /**
-* @param {Object} proverbs: object
+* @param array of proverbs
 * @return {Object} containing the action type and data
 */
 export function loadProverbsSuccess(proverbs) {
   return { type: types.LOAD_PROVERBS_SUCCESS, proverbs };
 }
 
 /**
-* @param {Object} proverbs: object
-* @return {Object} containing the action type and data
-*/
-export function loadProverbSuccess(proverb) {
-  return { type: types.LOAD_PROVERB_SUCCESS, proverb };
-}
-
-/**
-* @param {Object} proverbs: key proverbs and value is an array of questions
+* @param {Object} proverb
 * @return {Object} containing the action type and proverb
 */
 export function updateProverbSuccess(proverb) {
   return { type: types.UPDATE_PROVERB_SUCCESS, proverb };
 }
 
-export function createProverbSuccess(proverb) {
-  return { 
-    type: types.CREATE_PROVERB_SUCCESS, 
-    proverb
-  };
-}
-
-export function loadProverbs() {
+export function loadProverbs(locale) {
+  const defaultLocale = locale ? locale : 'en';
   return dispatch => {
-    return webAPI(`/proverbs`, 'GET', '')
+    return webAPI(`${'/' + defaultLocale + '/proverbs'}`, 'GET', '')
       .then(res => {
-        dispatch(loadProverbsSuccess(res.proverbs));
-      });
-  };
-}
-
-export function loadProverb(proverbId) {
-  return dispatch => {
-    return mockProverbApi.getProverb(proverbId)
-      .then(proverb => {
-        dispatch(loadProverbSuccess(proverb));
+        dispatch(loadProverbsSuccess(res));
       });
   };
 }
 
 export function saveProverb(proverb) {
+  const type = proverb.id ? 'PUT' : 'POST';
+  const rootUrl = `/proverbs`;
+  const url = proverb.id ? `${rootUrl + '/' + proverb.id}` : rootUrl;
+
   return (dispatch) => {
-    return mockProverbApi.saveProverb(proverb).then(proverb => {
-      proverb.id ? dispatch(updateProverbSuccess(proverb))
-      : dispatch(createProverbSuccess(proverb));
-    }).catch(error => {
-      throw error;
-    });
+    return webAPI(url, type, proverb)
+      .then(res => {
+        dispatch(updateProverbSuccess(res))       
+      })
   };
 }

src/js/actions/proverbActions.spec.js

@@ -1,65 +1,97 @@
 import expect from 'expect';
-import * as proverbActions from './proverbActions';
-import * as types from './actionTypes';
 import thunk from 'redux-thunk';
 import nock from 'nock';
 import configureMockStore from 'redux-mock-store';
-
+import { omit } from 'underscore';
 import Config from '../config/environment';
+import * as proverbActions from './proverbActions';
+import * as types from './actionTypes';
 
-describe('loadProverbsSuccess', () => {
-  describe('Create load Proverbs Action', () => {
-    it('should create a LOAD_PROVERBS_SUCCESS action', () => {
-      // setup
-      const proverbs = [
-        {id: 'A1023'}
-      ];
-      const expectedAction = {
-        type: types.default.LOAD_PROVERBS_SUCCESS,
-        proverbs
-      };
-
-      // actions
-      const action = proverbActions.loadProverbsSuccess(proverbs);
-
-      // assertions
-      expect(action).toEqual(expectedAction);
-    });
-  });
-});
+const proverb = { id: 'A1023', body: 'Testing proverb' };
+const proverbs = [ proverb ]; 
 
-const middleware = [thunk];
-const mockStore = configureMockStore(middleware);
+describe('Proverb actions', () => {
 
-describe('loadProverbs', function() {
-  afterEach(() => {
-    nock.cleanAll();
-  });
-  // this.timeout(15000);
-  it('should dispatch a success action on successful API response', done => {
+  it('should create a LOAD_PROVERBS_SUCCESS action', () => {
+
+    const expectedAction = {
+      type: types.default.LOAD_PROVERBS_SUCCESS,
+      proverbs
+    };
+
+    // actions
+    const action = proverbActions.loadProverbsSuccess(proverbs);
+
+    // assertions
+    expect(action).toEqual(expectedAction);
+  }); 
+
+  it('should create a UPDATE_PROVERB_SUCCESS action', () => {
     // setup
-    const proverbs = [ {id: 'A1023', body: 'first proverb'} ];
-
-    nock(Config.host)
-    .get('/proverbs')
-    .reply(200, { proverbs });
-
-    const expectedActions = [
-      {type: types.default.LOAD_PROVERBS_SUCCESS, proverbs}
-    ];
-
-    // action
-    const initialAppState = { proverbs: [] };
-    const store = mockStore(initialAppState, expectedActions);
-
-    store.dispatch(
-      proverbActions.loadProverbs())
-      .then(() => {
-        const [ actions ] = store.getActions();
-        expect(actions.type).toEqual(types.default.LOAD_PROVERBS_SUCCESS);
-        expect(actions.proverbs).toEqual(proverbs);
-    });
+    const expectedUpdateAction = {
+      type: types.default.UPDATE_PROVERB_SUCCESS,
+      proverb
+    };
 
-    done();
+    // actions
+    const action = proverbActions.updateProverbSuccess(proverb);
+
+    // assertions
+    expect(action).toEqual(expectedUpdateAction);
   });
+
+  describe('Proverb action thunks', function() {
+
+    const middleware = [thunk];
+    const mockStore = configureMockStore(middleware);
+    const initialAppState = { proverbs: [], proverb: {} };
+
+    afterEach(() => {
+      nock.cleanAll();
+    });
+
+    // this.timeout(15000);
+    describe('loadProverbs', () => {
+      it('should dispatch a success action on successful API response', done => {
+
+        nock(Config.host)
+        .get('/proverbs')
+        .reply(200, proverbs);
+
+        const expectedActions = [
+          {type: types.default.LOAD_PROVERBS_SUCCESS, proverbs}
+        ];
+
+        // action
+        const store = mockStore(initialAppState, expectedActions);
+        store.dispatch(proverbActions.loadProverbs())
+          .then(() => {
+            const [actions] = store.getActions();
+            expect(actions.type).toEqual(types.default.LOAD_PROVERBS_SUCCESS);
+          });
+
+          done();
+      }); 
+    })
+
+    describe('saveProverbs', () => {
+      it('should dispatch a success action on successful API response', done => {
+
+        const expectedActions = [
+          {type: types.default.UPDATE_PROVERB_SUCCESS, proverb}
+        ];
+        
+        // action
+        const store = mockStore(initialAppState, expectedActions);
+        const [actions] = store.getActions();
+        store.dispatch(proverbActions.saveProverb(proverb))
+          .then(() => {
+            expect(actions.type).toEqual(types.default.UPDATE_PROVERB_SUCCESS);
+          });
+          
+          done();
+      }); 
+    })    
+  });  
+
 });

src/js/components/proverbs/proverb/Index.js

@@ -12,7 +12,6 @@ class Proverb extends Component {
     const { proverb } = this.props;
     this.state = {
       proverb,
-      errors    : {},
       loading   : false 
     };
 
@@ -41,14 +40,13 @@ class Proverb extends Component {
   }
 
   render() {
-    const { proverb, errors, loading } = this.state;
+    const { proverb, loading } = this.state;
     return (
       <div className="panel-container about-page">
         <h3>{`${this.props.params.proverbId ? "Edit" : "Create"} A Proverb`}</h3>
         <ProverbForm
           proverb={proverb}
           loading={loading}
-          errors={errors}
           handleSubmit={this.handleSubmit} 
         />
       </div>
@@ -68,7 +66,11 @@ Proverb.propTypes = {
 };
 
 const getProverbValues = (proverbId, proverbs) => {
-  const proverb = Object.values(proverbs).filter(proverb => proverb.id.toString() === proverbId);
+  const proverb = Object.values(proverbs)
+  .filter(
+    proverb => proverb.id.toString() === proverbId
+  );
+
   return !isEmpty(proverb) ? proverb[0] : null;
 }
 

src/js/components/proverbs/proverb/ProverbForm.js

@@ -151,7 +151,6 @@ class ProverbForm extends Component {
 ProverbForm.propTypes = {
   loading     : PropTypes.bool,
   proverb     : PropTypes.object.isRequired,
-  errors      : PropTypes.object.isRequired,
   handleSubmit: PropTypes.func
 };
 

src/js/reducers/proverbs/proverbReducer.js

@@ -10,14 +10,8 @@ export default function proverbReducer(state = initialState.proverbs, action) {
     case types.LOAD_PROVERB_SUCCESS:
       return storeHelpers.updateProverb(state, action.proverb);
 
-    case types.CREATE_PROVERB_SUCCESS:
-      return Object.assign({}, state, {[action.proverb.id]: action.proverb });
-
     case types.UPDATE_PROVERB_SUCCESS:
-      return storeHelpers.updateProverb(state, action.proverb);
-
-    case types.SAVE_PROVERB_ERROR:
-      return Object.assign({}, state, action.error);      
+      return storeHelpers.updateProverb(state, action.proverb);    
 
     default:
       return state;

src/js/reducers/proverbs/proverbReducer.spec.js

@@ -22,8 +22,8 @@ describe('Proverb Reducer Test', () => {
     expect(newState).toEqual(expectedState);
   });
 
-  it("should add a new proverb when passed UPDATE_PROVERB_SUCCESS" +
-    " if proverb doesn't already exist in store", () => {
+  it('should add a new proverb when passed UPDATE_PROVERB_SUCCESS' +
+    ' if proverb doesn\'t already exist in store', () => {
     const initialState = {
       1: {id: 1},
       2: {id: 2}
@@ -34,6 +34,7 @@ describe('Proverb Reducer Test', () => {
 
     // action
     const newState = proverbReducer(initialState, action);
+
     expect(Object.keys(newState).length).toEqual(3);
     expect(newState[1].id).toEqual(1);
     expect(newState[2].id).toEqual(2);
@@ -54,4 +55,5 @@ describe('Proverb Reducer Test', () => {
     expect(Object.keys(updatedState).length).toEqual(2);
     expect(updatedState[proverb.id].labor_cost).toEqual(34);
   });
+
 });