feat(overmind): expose onInitialize on mock to explicitly run

Author: christianalfoni

packages/node_modules/overmind/src/index.ts

@@ -80,6 +80,7 @@ export function createOvermindMock<Config extends Configuration>(
 ): {
   actions: ResolveMockActions<Config['actions']>
   state: ResolveState<Config['state']>
+  onInitialize: () => Promise<IMutation[]>
 } {
   const mock = new Overmind(
     Object.assign({}, config, {
@@ -116,6 +117,7 @@ export function createOvermindMock<Config extends Configuration>(
   return {
     actions: mock.actions as any,
     state: mock.state,
+    onInitialize: (mock as any).onInitialize,
   }
 }
 
@@ -263,7 +265,15 @@ export class Overmind<Config extends Configuration> implements Configuration {
     */
     this.actions = this.getActions(configuration)
 
-    if (configuration.onInitialize) {
+    if (options.testMode) {
+      const action = this.createAction(
+        'onInitialize',
+        configuration.onInitialize
+      )
+
+      const overmind = this as any
+      overmind.onInitialize = () => action(this)
+    } else if (configuration.onInitialize) {
       const onInitialize = this.createAction(
         'onInitialize',
         configuration.onInitialize

packages/node_modules/overmind/src/mock.test.ts

@@ -1,19 +1,19 @@
-import { createOvermindMock, IAction } from './'
+import { createOvermindMock, IAction, IOnInitialize } from './'
 
 type State = {
   foo: string
   upperFoo: string
 }
 
 describe('Mock', () => {
-  test('should run action tests', () => {
+  test('should run action tests', async () => {
     type State = {
       foo: string
     }
     const state: State = {
       foo: 'bar',
     }
-    const test: Action = ({ state, effects, actions }) => {
+    const test: Action = ({ state, effects }) => {
       state.foo = effects.effect()
     }
     const actions = { test }
@@ -35,14 +35,50 @@ describe('Mock', () => {
       },
     })
 
-    return overmind.actions.test().then((result) =>
-      expect(result).toEqual([
-        {
-          method: 'set',
-          path: 'foo',
-          args: ['bar3'],
-        },
-      ])
-    )
+    const result = await overmind.actions.test()
+
+    expect(result).toEqual([
+      {
+        method: 'set',
+        path: 'foo',
+        args: ['bar3'],
+      },
+    ])
+  })
+  test('should test onInitialize explicitly', async () => {
+    type State = {
+      foo: string
+    }
+    const state: State = {
+      foo: 'bar',
+    }
+    const onInitialize: OnInitialize = async ({ state }) => {
+      state.foo += '!'
+    }
+
+    const config = {
+      onInitialize,
+      state,
+    }
+
+    type Config = typeof config
+
+    interface OnInitialize extends IOnInitialize<Config> {}
+
+    const overmind = createOvermindMock(config, {
+      effect() {
+        return 'bar3'
+      },
+    })
+
+    const result = await overmind.onInitialize()
+
+    expect(result).toEqual([
+      {
+        method: 'set',
+        path: 'foo',
+        args: ['bar!'],
+      },
+    ])
   })
 })