feat(overmind): make overmind mock compatible with Provider

Author: christianalfoni

package-lock.json

@@ -87,7 +87,7 @@
     "raw-loader": "0.5.1",
     "react": "^16.8.1",
     "react-dom": "^16.8.1",
-    "react-test-renderer": "16.4.1",
+    "react-test-renderer": "^16.8.1",
     "repo-cooker": "^6.3.0",
     "rimraf": "2.6.2",
     "source-map-loader": "0.2.4",

package.json

@@ -12,6 +12,18 @@ exports[`React should allow using component as normal, even when not connected 2
 </h1>
 `;
 
+exports[`React should allow using hooks 1`] = `
+<h1>
+  bar
+</h1>
+`;
+
+exports[`React should allow using mocked Overmind 1`] = `
+<h1>
+  bar
+</h1>
+`;
+
 exports[`React should connect actions and state to class components 1`] = `
 <h1>
   bar

packages/node_modules/overmind-react/src/__snapshots__/index.test.tsx.snap

@@ -1,4 +1,4 @@
-import { Overmind, IAction } from 'overmind'
+import { Overmind, IAction, createOvermindMock } from 'overmind'
 import * as React from 'react'
 import * as renderer from 'react-test-renderer'
 import { IConnect, createConnect, createHook, Provider } from './'
@@ -185,4 +185,105 @@ describe('React', () => {
 
     expect(renderCount).toBe(2)
   })
+  test('should allow using hooks', () => {
+    let renderCount = 0
+
+    const doThis: Action = ({ state }) => {
+      state.foo = 'bar2'
+    }
+    const config = {
+      state: {
+        foo: 'bar',
+      },
+      actions: {
+        doThis,
+      },
+    }
+
+    type IConfig = {
+      state: {
+        foo: typeof config.state.foo
+      }
+      actions: {
+        doThis: typeof doThis
+      }
+    }
+
+    const app = new Overmind(config)
+
+    interface Action<Input = void> extends IAction<IConfig, Input> {}
+
+    const useOvermind = createHook<typeof app>()
+
+    const FooComponent: React.FunctionComponent = () => {
+      const { state } = useOvermind()
+      renderCount++
+
+      return <h1>{state.foo}</h1>
+    }
+
+    const tree = renderer
+      .create(
+        <Provider value={app}>
+          <FooComponent />
+        </Provider>
+      )
+      .toJSON()
+
+    expect(renderCount).toBe(1)
+
+    renderer.act(() => {
+      app.actions.doThis()
+    })
+
+    expect(renderCount).toBe(2)
+    expect(tree).toMatchSnapshot()
+  })
+  test('should allow using mocked Overmind', () => {
+    let renderCount = 0
+
+    const doThis: Action = ({ state }) => {
+      state.foo = 'bar2'
+    }
+    const config = {
+      state: {
+        foo: 'bar',
+      },
+      actions: {
+        doThis,
+      },
+    }
+
+    type IConfig = {
+      state: {
+        foo: typeof config.state.foo
+      }
+      actions: {
+        doThis: typeof doThis
+      }
+    }
+
+    interface Action<Input = void> extends IAction<IConfig, Input> {}
+
+    const useOvermind = createHook<typeof config>()
+
+    const FooComponent: React.FunctionComponent = () => {
+      const { state } = useOvermind()
+      renderCount++
+
+      return <h1>{state.foo}</h1>
+    }
+
+    const mock = createOvermindMock(config)
+    const tree = renderer
+      .create(
+        <Provider value={mock}>
+          <FooComponent />
+        </Provider>
+      )
+      .toJSON()
+
+    expect(renderCount).toBe(1)
+    expect(tree).toMatchSnapshot()
+  })
 })

packages/node_modules/overmind-react/src/index.test.tsx

@@ -1,4 +1,10 @@
-import { IConfiguration, IContext, EventType, Overmind } from 'overmind'
+import {
+  IConfiguration,
+  IContext,
+  EventType,
+  Overmind,
+  OvermindMock,
+} from 'overmind'
 import {
   // @ts-ignore
   __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
@@ -47,7 +53,7 @@ const context = createContext<Overmind<IConfiguration>>({} as Overmind<
 let nextComponentId = 0
 
 export const Provider: React.ProviderExoticComponent<
-  React.ProviderProps<Overmind<IConfiguration>>
+  React.ProviderProps<Overmind<IConfiguration> | OvermindMock<IConfiguration>>
 > = context.Provider
 
 export const createHook = <Config extends IConfiguration>(

packages/node_modules/overmind-react/src/index.ts

@@ -84,14 +84,17 @@ function deepCopy(obj) {
   return obj
 }
 
-export function createOvermindMock<Config extends IConfiguration>(
-  config: Config,
-  mockedEffects?: NestedPartial<Config['effects']>
-): {
+export interface OvermindMock<Config extends IConfiguration> {
   actions: ResolveMockActions<Config['actions']>
+  effects: Config['effects']
   state: ResolveState<Config['state']>
   onInitialize: () => Promise<IMutation[]>
-} {
+}
+
+export function createOvermindMock<Config extends IConfiguration>(
+  config: Config,
+  mockedEffects?: NestedPartial<Config['effects']>
+): OvermindMock<Config> {
   const mock = new Overmind(
     Object.assign({}, config, {
       state: deepCopy(config.state),
@@ -126,9 +129,11 @@ export function createOvermindMock<Config extends IConfiguration>(
 
   return {
     actions: mock.actions as any,
+    effects: mock.effects,
     state: mock.state,
     onInitialize: (mock as any).onInitialize,
-  }
+    proxyStateTree: (mock as any).proxyStateTree,
+  } as any
 }
 
 const hotReloadingCache = {}

packages/node_modules/overmind/src/index.ts

@@ -67,7 +67,7 @@ const overmind = new Overmind({
   actions: {}
 })
 
-export const useOvermind = createHook(overmind)
+export const useOvermind = createHook()
 `,
         },
         {