feat(overmind): add createMock for testing

christianalfoni · christianalfoni · commit 261917edd256 · 2019-01-08T23:07:15.000+01:00
diff --git a/packages/node_modules/overmind/src/index.ts b/packages/node_modules/overmind/src/index.ts
@@ -17,6 +17,7 @@ import {
   ResolveActions,
   ResolveState,
   Execution,
+  ResolveMockActions,
 } from './internalTypes'
 import { proxifyEffects } from './proxyfyEffects'
 import {
@@ -61,6 +62,76 @@ export const makeStringifySafeMutations = (mutations: IMutation[]) => {
   }))
 }
 
+function deepCopy(obj) {
+  if (isPlainObject(obj)) {
+    return Object.keys(obj).reduce((aggr, key) => {
+      aggr[key] = deepCopy(obj[key])
+
+      return aggr
+    }, {})
+  } else if (Array.isArray(obj)) {
+    return obj.map((item) => deepCopy(item))
+  }
+
+  return obj
+}
+
+export function createMock<Config extends Configuration>(
+  config: Config,
+  effectsCallback?: (
+    effect: {
+      path: string
+      args: any[]
+    },
+    index: number
+  ) => any
+): {
+  actions: ResolveMockActions<Config['actions']>
+  state: ResolveState<Config['state']>
+} {
+  let effectCount = 0
+  let effectsCalled = []
+  const mock = new Overmind(
+    Object.assign({}, config, {
+      state: deepCopy(config.state),
+    }),
+    {
+      devtools: false,
+      testMode: {
+        effectsCallback: (effect) => {
+          if (!effectsCallback) {
+            return
+          }
+
+          return effectsCallback(
+            {
+              path: effect.name + '.' + effect.method,
+              args: effect.args,
+            },
+            effectCount++
+          )
+        },
+        actionCallback: (execution) => {
+          const effects = effectsCalled.slice()
+
+          effectCount = 0
+          effectsCalled.length = 0
+
+          return {
+            mutations: execution.flush().mutations,
+            effects,
+          }
+        },
+      },
+    }
+  )
+
+  return {
+    actions: mock.actions as any,
+    state: mock.state,
+  }
+}
+
 const hotReloadingCache = {}
 
 // We do not use TConfig<Config> directly to type the class in order to avoid
@@ -70,6 +141,7 @@ export class Overmind<Config extends Configuration> implements Configuration {
   private proxyStateTree: ProxyStateTree<object>
   private actionReferences: Function[] = []
   private nextExecutionId: number = 0
+  private options: Options
   initialized: Promise<any>
   eventHub: EventEmitter<Events>
   devtools: Devtools
@@ -108,6 +180,7 @@ export class Overmind<Config extends Configuration> implements Configuration {
     this.effects = configuration.effects || {}
     this.proxyStateTree = proxyStateTree
     this.eventHub = eventHub
+    this.options = options
 
     if (!IS_PRODUCTION && typeof window !== 'undefined') {
       let warning = 'OVERMIND: You are running in DEVELOPMENT mode.'
@@ -157,7 +230,7 @@ export class Overmind<Config extends Configuration> implements Configuration {
         nextTick && clearTimeout(nextTick)
         nextTick = setTimeout(flushTree, 0)
       })
-    } else {
+    } else if (!options.testMode) {
       eventHub.on(EventType.OPERATOR_ASYNC, (execution) => {
         const flushData = execution.flush()
         if (this.devtools && flushData) {
@@ -264,7 +337,7 @@ export class Overmind<Config extends Configuration> implements Configuration {
   }
   private createAction(name, action) {
     this.actionReferences.push(action)
-    return (value?) => {
+    const actionFunc = (value?) => {
       if (IS_PRODUCTION || action[IS_OPERATOR]) {
         return new Promise((resolve, reject) => {
           const execution = this.createExecution(name, action)
@@ -288,15 +361,19 @@ export class Overmind<Config extends Configuration> implements Configuration {
                       operatorId: finalContext.execution.operatorId - 1,
                     })
                   if (err) reject(err)
-                  else resolve(finalContext.value)
+                  else resolve(this.options.testMode && finalContext.execution)
                 }
               )
-            : action(
-                this.createContext(
-                  value,
-                  execution,
-                  execution.getMutationTree()
+            : resolve(
+                action(
+                  this.createContext(
+                    value,
+                    execution,
+                    execution.getMutationTree()
+                  )
                 )
+                  ? undefined
+                  : undefined
               )
         })
       } else {
@@ -332,32 +409,94 @@ export class Overmind<Config extends Configuration> implements Configuration {
           })
         })
 
-        const result = action(
-          this.createContext(
-            this.scopeValue(value, mutationTree),
-            execution,
-            mutationTree
-          )
+        const context = this.createContext(
+          this.scopeValue(value, mutationTree),
+          execution,
+          mutationTree
         )
+        const result = action(context)
+
         this.eventHub.emit(EventType.OPERATOR_END, {
           ...execution,
           isAsync: result instanceof Promise,
           result: undefined,
         })
         this.eventHub.emit(EventType.ACTION_END, execution)
 
-        return Promise.resolve(result)
+        return Promise.resolve(this.options.testMode && execution)
       }
     }
+
+    if (this.options.testMode) {
+      const actionCallback = this.options.testMode.actionCallback
+
+      return (value?) => (actionFunc as any)(value).then(actionCallback)
+    }
+
+    return actionFunc
   }
   private trackEffects(effects = {}, execution) {
     if (IS_PRODUCTION) {
       return effects
     }
 
-    return proxifyEffects(this.effects, (effect) =>
-      this.eventHub.emit(EventType.EFFECT, { ...execution, ...effect })
-    )
+    return proxifyEffects(this.effects, (effect) => {
+      let result
+      try {
+        result = this.options.testMode
+          ? this.options.testMode.effectsCallback(effect)
+          : effect.func.apply(this, effect.args)
+      } catch (error) {
+        // eslint-disable-next-line standard/no-callback-literal
+        this.eventHub.emit(EventType.EFFECT, {
+          ...execution,
+          ...effect,
+          isPending: false,
+          error: error.message,
+        })
+        return
+      }
+
+      if (result instanceof Promise) {
+        // eslint-disable-next-line standard/no-callback-literal
+        this.eventHub.emit(EventType.EFFECT, {
+          ...execution,
+          ...effect,
+          isPending: true,
+          error: false,
+        })
+        result
+          .then((promisedResult) => {
+            // eslint-disable-next-line standard/no-callback-literal
+            this.eventHub.emit(EventType.EFFECT, {
+              ...execution,
+              ...effect,
+              result: promisedResult,
+              isPending: false,
+              error: false,
+            })
+          })
+          .catch((error) => {
+            this.eventHub.emit(EventType.EFFECT, {
+              ...execution,
+              ...effect,
+              isPending: false,
+              error: error.message,
+            })
+          })
+      } else {
+        // eslint-disable-next-line standard/no-callback-literal
+        this.eventHub.emit(EventType.EFFECT, {
+          ...execution,
+          ...effect,
+          result,
+          isPending: false,
+          error: false,
+        })
+      }
+
+      return result
+    })
   }
   private initializeDevtools(host, eventHub, proxyStateTree) {
     const devtools = new Devtools(
diff --git a/packages/node_modules/overmind/src/internalTypes.ts b/packages/node_modules/overmind/src/internalTypes.ts
@@ -10,6 +10,17 @@ export type Options = {
   name?: string
   devtools?: string | boolean
   logProxies?: boolean
+  testMode?: {
+    effectsCallback: (
+      effect: {
+        effectId: number
+        name: string
+        method: string
+        args: any[]
+      }
+    ) => {}
+    actionCallback: (execution: any) => void
+  }
 }
 
 export enum EventType {
@@ -169,15 +180,48 @@ export type ResolveActions<
   : {
       [T in keyof Actions]: Actions[T] extends TAction<any, any>
         ? [TActionValue<Actions[T]>] extends [void]
-          ? () => Promise<ReturnType<Actions[T]>>
-          : (value: TActionValue<Actions[T]>) => Promise<ReturnType<Actions[T]>>
+          ? () => Promise<void>
+          : (value: TActionValue<Actions[T]>) => Promise<void>
         : Actions[T] extends TOperator<any, any, any>
         ? [TOperationValue<Actions[T]>] extends [void]
-          ? () => Promise<ReturnType<Actions[T]>>
-          : (
-              value: TOperationValue<Actions[T]>
-            ) => Promise<ReturnType<Actions[T]>>
+          ? () => Promise<void>
+          : (value: TOperationValue<Actions[T]>) => Promise<void>
         : Actions[T] extends NestedActions
         ? ResolveActions<Actions[T]>
         : never
     }
+
+type NestedMockActions =
+  | {
+      [key: string]:
+        | TAction<any, any>
+        | TOperator<any, any, any>
+        | NestedMockActions
+    }
+  | undefined
+
+type MockResult = {
+  mutations: IMutation[]
+  effects: ({
+    path: string
+    args: any[]
+  })[]
+}
+
+export type ResolveMockActions<
+  Actions extends NestedMockActions
+> = Actions extends undefined
+  ? {}
+  : {
+      [T in keyof Actions]: Actions[T] extends TAction<any, any>
+        ? [TActionValue<Actions[T]>] extends [void]
+          ? () => Promise<MockResult>
+          : (value: TActionValue<Actions[T]>) => Promise<MockResult>
+        : Actions[T] extends TOperator<any, any, any>
+        ? [TOperationValue<Actions[T]>] extends [void]
+          ? () => Promise<MockResult>
+          : (value: TOperationValue<Actions[T]>) => Promise<MockResult>
+        : Actions[T] extends NestedMockActions
+        ? ResolveMockActions<Actions[T]>
+        : never
+    }
diff --git a/packages/node_modules/overmind/src/mock.test.ts b/packages/node_modules/overmind/src/mock.test.ts
@@ -0,0 +1,47 @@
+import { createMock, TAction } from './'
+
+type State = {
+  foo: string
+  upperFoo: string
+}
+
+describe('Mock', () => {
+  test('should run action tests', () => {
+    type State = {
+      foo: string
+    }
+    const state: State = {
+      foo: 'bar',
+    }
+    const test: Action = ({ state }) => {
+      state.foo = 'bar2'
+    }
+    const actions = { test }
+    const config = {
+      state,
+      actions,
+    }
+
+    type Config = {
+      state: typeof state
+      actions: typeof actions
+    }
+
+    type Action<Input = void> = TAction<Config, Input>
+
+    const mock = createMock(config)
+
+    return mock.actions.test().then((result) =>
+      expect(result).toEqual({
+        mutations: [
+          {
+            method: 'set',
+            path: 'foo',
+            args: ['bar2'],
+          },
+        ],
+        effects: [],
+      })
+    )
+  })
+})
diff --git a/packages/node_modules/overmind/src/proxyfyEffects.ts b/packages/node_modules/overmind/src/proxyfyEffects.ts
