Added useCallback and useMemo tests

Author: mpeyper

src/flush.js

@@ -0,0 +1,9 @@
+import invariant from 'invariant'
+
+export default (context) => () => {
+  invariant(context.flush, 'You must use the hook before effects can be flushed')
+
+  context.flush()
+
+  return context.result
+}

src/flushEffects.js

@@ -16,7 +16,7 @@ export default (hook, context) => (props) => {
 
   context.update({
     rerender: (newProps) => rerender(context.resolveComponent(<HookHarness {...newProps} />)),
-    flushEffects: () => context.rerender(props)
+    flush: () => context.rerender(props)
   })
 
   return context.result

src/use.js

@@ -1,13 +1,13 @@
 import use from './use'
 import withContextProvider from './withContextProvider'
+import flush from './flush'
 import update from './update'
-import flushEffects from './flushEffects'
 
 export default (hook, context) => {
   return {
     use: use(hook, context),
     withContextProvider: withContextProvider(hook, context),
-    update: update(context),
-    flushEffects: flushEffects(context)
+    flush: flush(context),
+    update: update(context)
   }
 }

src/useHookAdvanced.js

@@ -1,40 +1,35 @@
-import React, { useState, useContext, createContext, useEffect } from 'react'
+import {
+  useState,
+  useContext,
+  createContext,
+  useEffect,
+  useReducer,
+  useCallback,
+  useMemo
+} from 'react'
 import { useHook, cleanup } from 'src'
 
 describe('useHook tests', () => {
   afterEach(cleanup)
 
-  test('should handle useState hooks', () => {
-    const { use, update } = useHook(() => useState('foo'))
+  test('should handle useState hook', () => {
+    const { use, flush } = useHook(() => useState('foo'))
 
     const [value1, setValue] = use()
 
     expect(value1).toBe('foo')
 
     setValue('bar')
 
-    const [value2] = update()
+    const [value2] = flush()
 
     expect(value2).toBe('bar')
   })
 
-  test('should handle useContext hooks', () => {
-    const TestContext = createContext('foo')
-
-    const { use } = useHook(() => useContext(TestContext)).withContextProvider(
-      TestContext.Provider,
-      { value: 'bar' }
-    )
-
-    const value = use()
-
-    expect(value).toBe('bar')
-  })
-
-  test('should handle useEffect hooks', () => {
+  test('should handle useEffect hook', () => {
     const sideEffect = { [1]: false, [2]: false }
 
-    const { use, flushEffects, update } = useHook(({ id }) =>
+    const { use, flush, update } = useHook(({ id }) =>
       useEffect(
         () => {
           sideEffect[id] = true
@@ -51,7 +46,7 @@ describe('useHook tests', () => {
     expect(sideEffect[1]).toBe(false)
     expect(sideEffect[2]).toBe(false)
 
-    flushEffects()
+    flush()
 
     expect(sideEffect[1]).toBe(true)
     expect(sideEffect[2]).toBe(false)
@@ -61,9 +56,86 @@ describe('useHook tests', () => {
     expect(sideEffect[1]).toBe(true)
     expect(sideEffect[2]).toBe(false)
 
-    flushEffects()
+    flush()
 
     expect(sideEffect[1]).toBe(false)
     expect(sideEffect[2]).toBe(true)
   })
+
+  test('should handle useContext hook', () => {
+    const TestContext = createContext('foo')
+
+    const { use } = useHook(() => useContext(TestContext)).withContextProvider(
+      TestContext.Provider,
+      { value: 'bar' }
+    )
+
+    const value = use()
+
+    expect(value).toBe('bar')
+  })
+
+  test('should handle useReducer hook', () => {
+    const reducer = (state, action) => (action.type === 'inc' ? state + 1 : state)
+    const { use, flush } = useHook(() => useReducer(reducer, 0))
+
+    const [initialState, dispatch] = use()
+
+    expect(initialState).toBe(0)
+
+    dispatch({ type: 'inc' })
+
+    const [state] = flush()
+
+    expect(state).toBe(1)
+  })
+
+  test('should handle useCallback hook', () => {
+    const { use, flush, update } = useHook(({ value }) => {
+      const callback = () => ({ value })
+      return useCallback(callback, [value])
+    })
+
+    const callback1 = use({ value: 1 })
+
+    const calbackValue1 = callback1()
+
+    expect(calbackValue1).toEqual({ value: 1 })
+
+    const callback2 = flush()
+
+    const calbackValue2 = callback2()
+
+    expect(calbackValue2).toEqual({ value: 1 })
+
+    expect(callback2).toBe(callback1)
+
+    const callback3 = update({ value: 2 })
+
+    const calbackValue3 = callback3()
+
+    expect(calbackValue3).toEqual({ value: 2 })
+
+    expect(callback3).not.toBe(callback1)
+  })
+
+  test('should handle useMemo hook', () => {
+    const { use, flush, update } = useHook(({ value }) => useMemo(() => ({ value }), [value]))
+
+    const value1 = use({ value: 1 })
+
+    expect(value1).toEqual({ value: 1 })
+
+    const value2 = flush()
+
+    expect(value2).toEqual({ value: 1 })
+
+    expect(value2).toBe(value1)
+
+    const value3 = update({ value: 2 })
+
+    expect(value3).toEqual({ value: 2 })
+
+    expect(value3).not.toBe(value1)
+  })
 })