Merge pull request #4 from bernabe9/init_tests

Init tests

Author: Bernabé González

.eslintrc

@@ -19,7 +19,7 @@
     "browser": true,
     "node": true,
     "jquery": true,
-    "mocha": true
+    "jest": true
   },
   "rules": {
     "quotes": 0,

.gitignore

@@ -17,5 +17,8 @@ node_modules
 #dist folder
 dist
 
+#coverage folder
+coverage
+
 # Mac files
 .DS_Store

.npmignore

@@ -8,5 +8,11 @@ src
 # Example folder
 example
 
+# Mocks folder
+__mocks__
+
+# Coverage folder
+coverage
+
 # Mac files
 .DS_Store

.travis.yml

@@ -0,0 +1,10 @@
+language: node_js
+node_js:
+  - "6"
+  - "5"
+  - "4"
+script:
+  - npm run lint
+  - npm run test
+after_success:
+  - npm run test:cover:CI

__mocks__/localforage.js

@@ -0,0 +1,62 @@
+'use strict';
+
+import { USER_SESSION, USER_DATA } from '../src/constants';
+
+const localforage = jest.genMockFromModule('localforage');
+
+let throwError = false;
+let user = undefined;
+let session = undefined;
+
+function __setError(error) {
+  throwError = error;
+}
+
+function __setUser(item) {
+  user = item;
+}
+
+function __setSession(item) {
+  session = item;
+}
+
+function setItem(item, data) {
+  return new Promise((resolve, reject) => {
+    if (item === USER_SESSION) {
+      session = data;
+    } else if (item === USER_DATA) {
+      user = data;
+    }
+    throwError ? reject() : resolve(data);
+  });
+}
+
+function getItem(item) {
+  return new Promise((resolve) => {
+    if (item === USER_SESSION) {
+      return resolve(session);
+    } else if (item === USER_DATA) {
+      return resolve(user);
+    }
+  });
+}
+
+function removeItem(item) {
+  return new Promise((resolve) => {
+    if (item === USER_SESSION) {
+      session = undefined;
+    } else if (item === USER_DATA) {
+      user = undefined;
+    }
+    resolve();
+  });
+}
+
+localforage.setItem = setItem;
+localforage.getItem = getItem;
+localforage.removeItem = removeItem;
+localforage.__setError = __setError;
+localforage.__setUser = __setUser;
+localforage.__setSession = __setSession;
+
+module.exports = localforage;

package.json

@@ -5,7 +5,9 @@
   "main": "dist/index.js",
   "scripts": {
     "build": "npm run clean && babel src --out-dir dist",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest",
+    "test:cover": "npm run test -- --coverage",
+    "test:cover:CI": "npm run test:cover && cat ./coverage/lcov.info | node_modules/coveralls/bin/coveralls.js",
     "lint": "eslint src",
     "clean": "rimraf dist"
   },
@@ -31,6 +33,7 @@
     "babel-cli": "6.23.0",
     "babel-core": "6.23.1",
     "babel-eslint": "7.1.1",
+    "babel-jest": "18.0.0",
     "babel-loader": "6.3.0",
     "babel-plugin-transform-react-constant-elements": "6.23.0",
     "babel-plugin-transform-react-remove-prop-types": "0.3.2",
@@ -40,12 +43,14 @@
     "babel-preset-react-hmre": "1.1.1",
     "babel-preset-stage-1": "6.22.0",
     "babel-register": "6.23.0",
+    "coveralls": "2.11.16",
     "eslint": "3.15.0",
     "eslint-plugin-import": "2.2.0",
+    "jest": "^18.1.0",
     "react": "15.4.2",
     "react-dom": "15.4.2",
     "redux": "3.6.0",
-    "rimraf": "^2.5.4",
+    "rimraf": "2.5.4",
     "webpack": "2.2.1"
   },
   "dependencies": {

src/__tests__/index.spec.js

@@ -0,0 +1,192 @@
+'use strict';
+
+import { sessionService, sessionReducer } from '../index';
+import { initialState } from '../reducer';
+import { createStore } from 'redux';
+import { __setError, __setSession, __setUser } from 'localforage';
+
+jest.mock('localforage');
+
+describe('API functions', () => {
+  let store;
+  const user = { email: 'test@test.com', firstName: 'test', lastName: 'test' };
+  const session = { token: '12341234' };
+  beforeAll((done) => {
+    store = createStore(sessionReducer, initialState);
+
+    // wait for refresh redux store from localStorage
+    const unsubscribe = store.subscribe(() => {
+      unsubscribe();
+      done();
+    });
+    sessionService.initSessionService(store);
+  });
+
+  describe('refreshFromLocalStorage', () => {
+    describe('without any item in the storage', () => {
+      test('change authenticated flag to false and the user to empty object', (done) => {
+        // wait for change the redux store
+        const unsubscribe = store.subscribe(() => {
+          expect(store.getState().authenticated).toEqual(false);
+          expect(store.getState().user).toEqual({});
+          unsubscribe();
+          done();
+        });
+
+        sessionService.refreshFromLocalStorage();
+      });
+    });
+
+    describe('with session and user in the storage', () => {
+      test('change authenticated flag to true and save the user', (done) => {
+        __setUser(user);
+        __setSession(session);
+
+        // wait for change the redux store
+        const unsubscribe = store.subscribe(() => {
+          const state = store.getState();
+          expect(state.authenticated).toEqual(true);
+          // wait to change the user
+          const { user } = state;
+          if (!(Object.keys(user).length === 0 && user.constructor === Object)) {
+            expect(state.user).toMatchObject(user);
+            unsubscribe();
+            done();
+          }
+        });
+
+        sessionService.refreshFromLocalStorage(session);
+      });
+    });
+  });
+
+  describe('saveSession', () => {
+    describe('localforage returns success', () => {
+      test('change authenticated flag to true value', (done) => {
+        __setError(false);
+        // wait for change the redux store
+        const unsubscribe = store.subscribe(() => {
+          expect(store.getState().authenticated).toEqual(true);
+          unsubscribe();
+          done();
+        });
+
+        sessionService.saveSession(session);
+      });
+    });
+
+    describe('localforage returns error', () => {
+      test('change authenticated flag to false value', (done) => {
+        __setError(true);
+        // wait for change the redux store
+        const unsubscribe = store.subscribe(() => {
+          expect(store.getState().authenticated).toEqual(false);
+          unsubscribe();
+          done();
+        });
+
+        sessionService.saveSession(session);
+      });
+    });
+  });
+
+  describe('loadSession', () => {
+    describe('localforage returns success', () => {
+      test('return the correct value of the session stored', () => {
+        __setSession(session);
+        return sessionService.loadSession()
+        .then((currentSession) => {
+          expect(currentSession).toMatchObject(session);
+        });
+      });
+    });
+
+    describe('localforage returns error', () => {
+      test('return an error', () => {
+        __setSession(undefined);
+        return sessionService.loadSession()
+        .catch((error) => {
+          expect(error).toEqual('Session not found');
+        });
+      });
+    });
+  });
+
+  describe('deleteSession', () => {
+    test('change authenticated flag to false value', (done) => {
+      // wait for change the redux store
+      const unsubscribe = store.subscribe(() => {
+        expect(store.getState().authenticated).toEqual(false);
+        unsubscribe();
+        done();
+      });
+
+      sessionService.deleteSession();
+    });
+  });
+
+  describe('saveUser', () => {
+    describe('localforage returns success', () => {
+      test('change user in store to the user data', (done) => {
+        __setError(false);
+        // wait for change the redux store
+        const unsubscribe = store.subscribe(() => {
+          expect(store.getState().user).toMatchObject(user);
+          unsubscribe();
+          done();
+        });
+
+        sessionService.saveUser(user);
+      });
+    });
+
+    describe('localforage returns error', () => {
+      test('change user in store to an empty object', (done) => {
+        __setError(true);
+        // wait for change the redux store
+        const unsubscribe = store.subscribe(() => {
+          expect(store.getState().user).toMatchObject({});
+          unsubscribe();
+          done();
+        });
+
+        sessionService.saveUser(user);
+      });
+    });
+  });
+
+  describe('loadUser', () => {
+    describe('localforage returns success', () => {
+      test('return the correct value of the user stored', () => {
+        __setUser(user);
+        return sessionService.loadUser()
+        .then((currentUser) => {
+          expect(currentUser).toMatchObject(user);
+        });
+      });
+    });
+
+    describe('localforage returns error', () => {
+      test('return an error', () => {
+        __setUser(undefined);
+        return sessionService.loadUser()
+        .catch((error) => {
+          expect(error).toEqual('User not found');
+        });
+      });
+    });
+  });
+
+  describe('deleteUser', () => {
+    test('change user in store to an empty object', (done) => {
+      // wait for change the redux store
+      const unsubscribe = store.subscribe(() => {
+        expect(store.getState().user).toEqual({});
+        unsubscribe();
+        done();
+      });
+
+      sessionService.deleteUser();
+    });
+  });
+});

src/__tests__/reducer.spec.js

@@ -0,0 +1,67 @@
+import reducer, { initialState } from '../reducer';
+import {
+  GET_SESSION_SUCCESS,
+  GET_SESSION_ERROR,
+  GET_USER_SESSION_SUCCESS,
+  GET_USER_SESSION_ERROR
+} from '../actionTypes';
+
+describe('Reducer', () => {
+  test('set initial state by default', () => {
+    const action = { type: 'unknown' };
+    const expected = initialState;
+
+    expect(reducer(undefined, action)).toEqual(expected);
+  });
+
+  describe('GET_SESSION_SUCCESS', () => {
+    const action = { type: GET_SESSION_SUCCESS };
+
+    test('change authenticated to true value', () => {
+      expect(reducer(initialState, action).authenticated).toEqual(true);
+    });
+
+    test('not change the user object', () => {
+      expect(reducer(initialState, action).user).toEqual(initialState.user);
+    });
+  });
+
+  describe('GET_SESSION_ERROR', () => {
+    const action = { type: GET_SESSION_ERROR };
+
+    test('change authenticated to false value', () => {
+      expect(reducer(initialState, action).authenticated).toEqual(false);
+    });
+
+    test('not change the user object', () => {
+      expect(reducer(initialState, action).user).toEqual(initialState.user);
+    });
+  });
+
+  describe('GET_USER_SESSION_SUCCESS', () => {
+    const user = { email: 'test@test.com', firstName: 'test', lastName: 'test' };
+    const action = { user, type: GET_USER_SESSION_SUCCESS };
+
+    test('save the new user', () => {
+      expect(reducer(initialState, action).user).toEqual(user);
+    });
+
+    test('not change the authenticated flag', () => {
+      expect(reducer(initialState, action).authenticated).toEqual(initialState.authenticated);
+    });
+  });
+
+  describe('GET_USER_SESSION_ERROR', () => {
+    const user = { email: 'test@test.com', firstName: 'test', lastName: 'test' };
+    const modificatedState = { user, authenticated: true };
+    const action = { type: GET_USER_SESSION_ERROR };
+
+    test('remove the saved user', () => {
+      expect(reducer(modificatedState, action).user).toEqual({});
+    });
+
+    test('not change the authenticated flag', () => {
+      expect(reducer(modificatedState, action).authenticated).toEqual(modificatedState.authenticated);
+    });
+  });
+});