fix(overmind): make copy of statemachines during mocking

Author: christianalfoni

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

@@ -239,4 +239,47 @@ describe('Statemachine', () => {
 
     return overmind.actions.transition()
   })
+  test('should make copy of statemachine during tests', () => {
+
+    type States = {
+      state: 'FOO'
+      obj: {
+        foo: string
+      }
+    } | {
+      state: 'BAR'
+      obj: {
+        foo: string
+      }
+    }
+
+    const state = statemachine<States>({
+      FOO: ['BAR'],
+      BAR: ['FOO']
+    }, {
+      state: 'FOO',
+      obj: {
+        foo: 'bar'
+      }
+    })
+    const config = {
+      state,
+      actions: {
+        changeFoo({ state }) {
+          state.obj.foo = 'bar2'
+        }
+      }
+    } 
+
+    const overmind = createOvermindMock(config)
+
+    // @ts-ignore
+    overmind.actions.changeFoo()
+    expect(overmind.state.obj.foo).toBe('bar2')
+
+
+    const overmind2 = createOvermindMock(config)
+
+    expect(overmind2.state.obj.foo).toBe('bar')
+  })
 })

packages/node_modules/overmind/src/statemachine.ts

@@ -1,5 +1,5 @@
 import { PROXY_TREE, VALUE } from 'proxy-state-tree'
-
+import { deepCopy } from './utils'
 import { IState } from '.'
 
 type TStates = IState & {
@@ -25,14 +25,20 @@ export type Statemachine<States extends TStates, State extends TStates = States>
 
 const INITIAL_STATE = Symbol('INITIAL_STATE')
 const TRANSITIONS = Symbol('TRANSITIONS')
+const STATE = Symbol('STATE')
 
-class StateMachine<States extends TStates, State extends TStates = States>  {
+export class StateMachine<States extends TStates, State extends TStates = States>  {
   state: State["state"]
   private [INITIAL_STATE]: State["state"]
-  constructor(transitions: StatemachineTransitions<States>, definition: States) {
-    this[INITIAL_STATE] = definition.state
+  private [STATE]: any
+  private clone() {
+    return new StateMachine(this[TRANSITIONS], deepCopy(this[STATE]))
+  }
+  constructor(transitions: StatemachineTransitions<States>, state: States) {
+    this[STATE] = state
+    this[INITIAL_STATE] = state.state
     this[TRANSITIONS] = transitions
-    Object.assign(this, definition)
+    Object.assign(this, state)
   }
   transition(state) {
     const transitions = this[VALUE][TRANSITIONS]
@@ -60,6 +66,6 @@ class StateMachine<States extends TStates, State extends TStates = States>  {
   }
 }
 
-export function statemachine<States extends TStates>(definition: StatemachineTransitions<States>, state: States): Statemachine<States> {
-  return new StateMachine(definition, state) as any
+export function statemachine<States extends TStates>(transitions: StatemachineTransitions<States>, state: States): Statemachine<States> {
+  return new StateMachine(transitions, state) as any
 }

packages/node_modules/overmind/src/utils.ts

@@ -1,5 +1,6 @@
 import isPlainObject from 'is-plain-obj'
 import { IMutation, IS_PROXY, VALUE } from 'proxy-state-tree'
+import { StateMachine } from './statemachine'
 
 export const IS_TEST = process.env.NODE_ENV === 'test'
 export const IS_OPERATOR = Symbol('operator')
@@ -62,7 +63,9 @@ export function getFunctionName(func: Function) {
 }
 
 export function deepCopy(obj) {
-  if (isPlainObject(obj)) {
+  if (obj instanceof StateMachine) {
+    return (obj as any).clone()
+  } else if (isPlainObject(obj)) {
     return Object.keys(obj).reduce((aggr: any, key) => {
       if (key === '__esModule') {
         return aggr