Test specificity improved for reducer, compose function, auth actions, populate utils, and events utils.

Author: prescottprue

src/actions/auth.js

@@ -267,7 +267,7 @@ export const createUser = (dispatch, firebase, { email, password, signIn }, prof
 
   if (!email || !password) {
     dispatchLoginError(dispatch, new Error('Email and Password are required to create user'))
-    return Promise.reject('Email and Password are Required')
+    return Promise.reject(new Error('Email and Password are Required'))
   }
 
   return firebase.auth()
@@ -311,7 +311,7 @@ export const resetPassword = (dispatch, firebase, email) => {
     .catch((err) => {
       if (err) {
         switch (err.code) {
-          case 'INVALID_USER':
+          case 'auth/user-not-found':
             dispatchLoginError(dispatch, new Error('The specified user account does not exist.'))
             break
           default:

src/compose.js

@@ -114,9 +114,9 @@ export default (config, otherConfig) => next =>
 // Expose Firebase instance
 export const getFirebase = () => {
   // TODO: Handle recieveing config and creating firebase instance if it doesn't exist
+  /* istanbul ignore next: Firebase instance always exists during tests */
   if (!firebaseInstance) {
-    console.error('Firebase instance does not yet exist. Check your compose function.') // eslint-disable-line no-console
-    return null
+    throw new Error('Firebase instance does not yet exist. Check your compose function.') // eslint-disable-line no-console
   }
   return firebaseInstance
 }

src/utils/events.js

@@ -56,7 +56,7 @@ export const getEventsFromInput = paths =>
     }
 
     if (isObject(path)) {
-      if (!path) {
+      if (!path.path) {
         throw new Error('Path is a required parameter within definition object')
       }
       if (!path.type) {

src/utils/populate.js

@@ -76,10 +76,10 @@ export const promisesForPopulate = (firebase, originalData, populates) => {
       if (isString(idOrList)) {
         return promisesArray.push(
           getPopulateChild(firebase, p, idOrList)
-          .then((v) =>
-            // replace parameter with loaded object
-            set(originalData, `${key}.${p.child}`, v)
-          )
+            .then((v) =>
+              // replace parameter with loaded object
+              set(originalData, `${key}.${p.child}`, v)
+            )
         )
       }
 

test/unit/actions/auth.spec.js

@@ -14,10 +14,8 @@ import {
 } from '../../../src/actions/auth'
 let functionSpy
 let dispatchSpy
-const dispatch = () => {
-  console.log('dispatch')
-}
-
+const dispatch = sinon.spy()
+const fakeLogin = { email: '[email protected]', password: 'asdfasdf' }
 const fakeFirebase = {
   _: {
     authUid: '123',
@@ -40,8 +38,10 @@ const fakeFirebase = {
     },
     signOut: () =>
       Promise.resolve({}),
-    createUserWithEmailAndPassword: () =>
-      Promise.resolve({ uid: '123', email: '[email protected]', providerData: [{}] }),
+    createUserWithEmailAndPassword: (email, password) =>
+      email === 'error'
+        ? Promise.reject({ code: 'asdfasdf' })
+        : Promise.resolve({ uid: '123', email: '[email protected]', providerData: [{}] }),
     signInWithCustomToken: () => {
       return Promise.resolve({
         toJSON: () => ({
@@ -51,7 +51,19 @@ const fakeFirebase = {
           uid: 'asdfasdfsdf'
         })
       })
-    }
+    },
+    signInWithEmailAndPassword: (email, password) =>
+      email.indexOf('error2') !== -1
+        ? Promise.reject({ code: 'asdfasdf' })
+        : email === 'error3'
+          ? Promise.reject({ code: 'auth/user-not-found' })
+          : Promise.resolve({ uid: '123', email: '[email protected]', providerData: [{}] }),
+    sendPasswordResetEmail: (email) =>
+      email === 'error'
+        ? Promise.reject({code: 'auth/user-not-found'})
+        : email === 'error2'
+          ? Promise.reject({code: 'asdfasdf'})
+          : Promise.resolve({some: 'val'})
   })
 }
 
@@ -87,6 +99,9 @@ describe('Actions: Auth', () => {
   })
 
   describe('watchUserProfile', () => {
+    beforeEach(() => {
+      functionSpy = sinon.spy()
+    })
     it('calls profile unwatch', () => {
       watchUserProfile(dispatch, fakeFirebase)
       expect(firebase._.profileWatch).to.be.a.function
@@ -95,6 +110,17 @@ describe('Actions: Auth', () => {
       watchUserProfile(dispatch, firebase)
       expect(firebase._.profileWatch).to.be.a.function
     })
+    it('sets populates using array', () => {
+      firebase._.config.profileParamsToPopulate = ['asdfasdf']
+      watchUserProfile(dispatch, firebase)
+      expect(firebase._.profileWatch).to.be.a.function
+    })
+    it('sets populates using string', () => {
+      firebase._.config.profileParamsToPopulate = 'asdfasdf'
+      watchUserProfile(dispatch, firebase)
+      expect(firebase._.profileWatch).to.be.a.function
+    })
+
   })
 
   describe('createUserProfile', () => {
@@ -108,7 +134,7 @@ describe('Actions: Auth', () => {
 
   describe('login', () => {
     it('handles invalid email login', () => {
-      return login(dispatch, firebase, { email: '[email protected]', password: 'asdfasdf' })
+      return login(dispatch, firebase, fakeLogin)
         .catch((err) => {
           expect(err.code).to.equal('auth/user-not-found')
         })
@@ -141,10 +167,7 @@ describe('Actions: Auth', () => {
           expect(functionSpy).to.have.been.calledOnce
         })
     })
-    it('calls firebase.auth().signOut()', () => {
-      logout(dispatch, firebase)
-      expect(functionSpy).to.have.been.calledOnce
-    })
+
     it('sets authUid to null', () => {
       fakeFirebase._.authUid = 'asdfasdf'
       return logout(dispatch, fakeFirebase)
@@ -162,41 +185,68 @@ describe('Actions: Auth', () => {
   })
 
   describe('createUser', () => {
-    // Skipped because of TypeError: Cannot read property 'apply' of undefined
-    it.skip('creates user', () => {
-      return createUser(dispatch, fakeFirebase, { email: '[email protected]', password: 'asdf' }, { email: '[email protected]', password: 'asdf' })
+    it('creates user', () =>
+      createUser(dispatch, fakeFirebase, fakeLogin, fakeLogin)
         .then(userData => {
           expect(userData).to.be.an.object
         })
-    })
-    it('handles no email', () => {
-      return createUser(dispatch, fakeFirebase, { password: 'asdf' })
+    )
+    it('creates user without profile', () =>
+      createUser(dispatch, fakeFirebase, fakeLogin)
+        .then(userData => {
+          expect(userData).to.be.an.object
+        })
+    )
+    it('handles no email', () =>
+      createUser(dispatch, fakeFirebase, { password: fakeLogin.password })
         .catch((err) => {
-          expect(err).to.be.a.string
+          expect(err).to.be.an.object
         })
-    })
-    it('handles no password', () => {
-      return createUser(dispatch, fakeFirebase, { email: '[email protected]' })
+    )
+    it('handles no password', () =>
+      createUser(dispatch, fakeFirebase, { email: fakeLogin.email })
         .catch((err) => {
-          expect(err).to.be.a.string
+          expect(err).to.be.an.object
         })
-    })
-  }, 4000)
+    )
+    it('handles error with createUserWithEmailAndPassword', () =>
+      createUser(dispatch, fakeFirebase, { email: 'error', password: 'error' })
+        .catch((err) => {
+          expect(err).to.be.an.object
+        })
+    )
+    it('handles error with login', () =>
+      createUser(dispatch, fakeFirebase, { email: 'error2', password: 'error2' })
+        .catch((err) => {
+          expect(err).to.be.an.object
+        })
+    )
+    it('handles user-not-found error', () =>
+      createUser(dispatch, fakeFirebase, { email: 'error3', password: 'error2' })
+        .catch((err) => {
+          expect(err).to.be.an.object
+        })
+    )
+  })
 
   describe('resetPassword', () => {
-    beforeEach(() => {
-      functionSpy = sinon.spy(firebase.auth(), 'sendPasswordResetEmail')
-    })
-    afterEach(() => {
-      firebase.auth().sendPasswordResetEmail.restore()
+    it('resets password for real user', () => {
+      return resetPassword(dispatch, fakeFirebase, '[email protected]')
+        .catch((err) => {
+          expect(err.code).to.equal('auth/user-not-found')
+        })
     })
     it('dispatches error for invalid user', () => {
-      return resetPassword(dispatch, firebase, '[email protected]')
+      return resetPassword(dispatch, fakeFirebase, 'error')
         .catch((err) => {
-          console.log('error', err)
           expect(err.code).to.equal('auth/user-not-found')
-          expect(functionSpy).to.have.been.calledOnce
         })
-    }, 4000)
+    })
+    it('dispatches for all other errors', () => {
+      return resetPassword(dispatch, fakeFirebase, 'error2')
+        .catch((err) => {
+          expect(err.code).to.be.a.string
+        })
+    })
   })
 })

test/unit/compose.spec.js

@@ -1,14 +1,15 @@
 /* global describe expect it */
 import { omit } from 'lodash'
 import { createStore, combineReducers, compose } from 'redux'
-import composeFunc from '../../src/compose'
+import composeFunc, { getFirebase } from '../../src/compose'
 const exampleData = { data: { some: 'data' } }
-const reducer = () => console.log('reducer', {})
+const reducer = sinon.spy()
 const generateCreateStore = (params) =>
   compose(composeFunc(
-    omit(fbConfig, params),
+    params ? omit(fbConfig, params) : fbConfig,
     { userProfile: 'users', enableLogging: true }
   ))(createStore)
+const helpers = generateCreateStore()(reducer).firebase.helpers
 
 describe('Compose', () => {
   it('is a function', () => {
@@ -18,23 +19,108 @@ describe('Compose', () => {
     expect(composeFunc(fbConfig)).to.be.a.function
   })
   it('allows enabling of Firebase database logging', () => {
-    const createStoreWithFirebase = compose(composeFunc(
-      fbConfig,
-      { userProfile: 'users', enableLogging: true }
-    ))(createStore)
-    expect(createStoreWithFirebase(reducer)).to.be.an.object
+    expect(generateCreateStore()(reducer))
+      .to.be.an.object
+  })
+
+  describe('helpers', () => {
+    describe('set', () =>
+      helpers.set('test', {some: 'asdf'})
+    )
+
+    describe('push', () =>
+      helpers.push('test', {some: 'asdf'})
+    )
+
+    describe('update', () =>
+      helpers.update('test', {some: 'asdf'})
+    )
+
+    describe('uniqueSet', () =>{
+      // remove test root after test are complete
+      after(() =>
+        helpers.remove('test')
+      )
+      it('sets if unique', () =>
+        helpers.uniqueSet('test/unique', {some: 'asdf'})
+      )
+      it('throws if not unique', () =>
+        helpers.uniqueSet('test', {some: 'asdf'})
+          .catch((err) => {
+            expect(err.toString()).to.equal('Error: Path already exists.')
+          })
+      )
+      it('has on err onComplete', () => {
+        const func = sinon.spy()
+        helpers.uniqueSet('test', {some: 'asdf'}, func)
+          .catch((err) => {
+            expect(func).to.have.been.calledOnce
+          })
+      })
+    })
+
+    describe('remove', () =>
+      helpers.remove('test')
+    )
+
+    describe('watchEvent', () =>
+      helpers.watchEvent('value', 'test')
+    )
+
+    describe('unWatchEvent', () =>
+      helpers.unWatchEvent('value', 'test')
+    )
+
+    describe('login', () => {
+      try {
+        helpers.login({ email: 'test' })
+      } catch (err) {
+        expect(err).to.be.an.object
+      }
+    })
+
+    describe('logout', () =>
+      helpers.logout()
+    )
+
+    describe('createUser', () =>
+      helpers.createUser({ email: 'test' }, { email: 'test' })
+    )
+
+    describe('resetPassword', () => {
+      try {
+        helpers.resetPassword({ email: 'test' })
+      } catch (err) {
+        expect(err).to.be.an.object
+      }
+    })
+    describe('storage', () => {
+      try {
+        helpers.storage()
+      } catch(err) {
+        expect(err).to.be.an.object
+      }
+    })
   })
-  describe('throws for missing fbConfig parameters', () => {
 
+  describe('throws for missing fbConfig parameters', () => {
     it('databaseURL', () => {
-      expect(() => generateCreateStore('databaseURL')(reducer)).to.throw('Firebase databaseURL is required')
+      expect(() => generateCreateStore('databaseURL')(reducer))
+        .to.throw('Firebase databaseURL is required')
     })
     it('authDomain', () => {
-      expect(() => generateCreateStore('authDomain')(reducer)).to.throw('Firebase authDomain is required')
+      expect(() => generateCreateStore('authDomain')(reducer))
+        .to.throw('Firebase authDomain is required')
     })
     it('apiKey', () => {
-      expect(() => generateCreateStore('apiKey')(reducer)).to.throw('Firebase apiKey is required')
+      expect(() => generateCreateStore('apiKey')(reducer))
+        .to.throw('Firebase apiKey is required')
     })
   })
 
+  describe('getFirebase', () => {
+    it('exports firebase instance', () => {
+      expect(getFirebase()).to.be.an.object
+    })
+  })
 })