Merge branch 'hotfix/fix-concurrency'

Author: fgmacedo

statemachine/state.py

@@ -1,5 +1,6 @@
 # coding: utf-8
 import warnings
+from copy import deepcopy
 from typing import Any
 from typing import Optional
 from typing import Text
@@ -84,15 +85,26 @@ def __init__(
         self.name = name
         self.value = value
         self._id = None  # type: Optional[Text]
+        self._storage = ""
         self._initial = initial
         self.transitions = TransitionList()
         self._final = final
         self.enter = Callbacks().add(enter)
         self.exit = Callbacks().add(exit)
 
-    def _setup(self, resolver):
+    def __eq__(self, other):
+        return (
+            isinstance(other, State) and self.name == other.name and self.id == other.id
+        )
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def _setup(self, machine, resolver):
+        self.machine = machine
         self.enter.setup(resolver)
         self.exit.setup(resolver)
+        machine.__dict__[self._storage] = self
 
     def _add_observer(self, *resolvers):
         for r in resolvers:
@@ -120,7 +132,8 @@ def __repr__(self):
         )
 
     def __get__(self, machine, owner):
-        self.machine = machine
+        if machine and self._storage in machine.__dict__:
+            return machine.__dict__[self._storage]
         return self
 
     def __set__(self, instance, value):
@@ -130,6 +143,9 @@ def __set__(self, instance, value):
             )
         )
 
+    def clone(self):
+        return deepcopy(self)
+
     @property
     def id(self):
         return self._id
@@ -144,6 +160,7 @@ def identifier(self):
 
     def _set_id(self, id):
         self._id = id
+        self._storage = "_{}".format(id)
         if self.value is None:
             self.value = id
 

statemachine/statemachine.py

@@ -1,6 +1,7 @@
 # coding: utf-8
 import sys
 import warnings
+from collections import OrderedDict
 from typing import Any
 from typing import Dict
 from typing import List
@@ -30,7 +31,9 @@ def __init__(self, model=None, state_field="state", start_value=None):
         self.state_field = state_field
         self.start_value = start_value
 
-        initial_transition = Transition(None, None, event="__initial__")
+        initial_transition = Transition(
+            None, self._get_initial_state(), event="__initial__"
+        )
         self._setup(initial_transition)
         self._activate_initial_state(initial_transition)
 
@@ -42,21 +45,19 @@ def __repr__(self):
             self.current_state.id if self.current_state else None,
         )
 
-    def _activate_initial_state(self, initial_transition):
-
+    def _get_initial_state(self):
         current_state_value = (
             self.start_value if self.start_value else self.initial_state.value
         )
-        if self.current_state_value is None:
-
-            try:
-                initial_state = self.states_map[current_state_value]
-            except KeyError:
-                raise InvalidStateValue(current_state_value)
+        try:
+            return self.states_map[current_state_value]
+        except KeyError:
+            raise InvalidStateValue(current_state_value)
 
+    def _activate_initial_state(self, initial_transition):
+        if self.current_state_value is None:
             # send an one-time event `__initial__` to enter the current state.
             # current_state = self.current_state
-            initial_transition.target = initial_state
             initial_transition.before.clear()
             initial_transition.on.clear()
             initial_transition.after.clear()
@@ -96,8 +97,22 @@ def _setup(self, initial_transition):
         model = ObjectConfig(self.model, skip_attrs={self.state_field})
         default_resolver = resolver_factory(machine, model)
 
-        initial_transition._setup(default_resolver)
-        self._visit_states_and_transitions(lambda x: x._setup(default_resolver))
+        # clone states and transitions to avoid sharing callbacks references between instances
+        states = []
+        self.states_map = OrderedDict()
+        for state in self.states:
+            new_state = state.clone()
+            new_state._setup(self, default_resolver)
+            states.append(new_state)
+            self.states_map[new_state.value] = new_state
+
+        self.states = states
+
+        for state in self.states:
+            for transition in state.transitions:
+                transition._setup(self, default_resolver)
+
+        initial_transition._setup(self, default_resolver)
         self.add_observer(machine, model)
 
     def add_observer(self, *observers):

statemachine/transition.py

@@ -61,7 +61,13 @@ def __repr__(self):
             type(self).__name__, self.source, self.target, self.event
         )
 
-    def _setup(self, resolver):
+    def _upd_state_refs(self, machine):
+        if self.source:
+            self.source = machine.__dict__[self.source._storage]
+        self.target = machine.__dict__[self.target._storage]
+
+    def _setup(self, machine, resolver):
+        self._upd_state_refs(machine)
         self.validators.setup(resolver)
         self.cond.setup(resolver)
         self.before.setup(resolver)

tests/examples/order_control_rich_model_machine.py

@@ -61,7 +61,7 @@ class OrderControl(StateMachine):
 try:
     control = OrderControl()
 except AttrNotFound as e:
-    assert str(e) == "Did not found name 'payment_received' from model or statemachine"
+    assert str(e) == "Did not found name 'wait_for_payment' from model or statemachine"
 
 # %%
 # Now initializing with a proper ``order`` instance.

tests/test_callbacks_isolation.py

@@ -0,0 +1,80 @@
+import pytest
+
+from statemachine import State
+from statemachine import StateMachine
+
+
+@pytest.fixture()
+def simple_sm_cls():
+    class TestStateMachine(StateMachine):
+        # States
+        initial = State("Initial", initial=True)
+        final = State("Final", final=True, enter="do_enter_final")
+
+        finish = initial.to(final, cond="can_finish", on="do_finish")
+
+        def __init__(self, name):
+            self.name = name
+            self.can_finish = False
+            self.finalized = False
+            super(TestStateMachine, self).__init__()
+
+        def do_finish(self):
+            return self.name, self.can_finish
+
+        def do_enter_final(self):
+            self.finalized = True
+
+    return TestStateMachine
+
+
+class TestCallbacksIsolation:
+    def test_should_conditions_be_isolated(self, simple_sm_cls):
+        sm1 = simple_sm_cls("sm1")
+        sm2 = simple_sm_cls("sm2")
+        sm3 = simple_sm_cls("sm3")
+
+        sm1.can_finish = True
+        assert sm1.initial.transitions[0].cond.call() == [True]
+        assert sm2.initial.transitions[0].cond.call() == [False]
+        assert sm3.initial.transitions[0].cond.call() == [False]
+
+    def test_should_actions_be_isolated(self, simple_sm_cls):
+        sm1 = simple_sm_cls("sm1")
+        sm2 = simple_sm_cls("sm2")
+
+        sm1.can_finish = True
+        sm2.can_finish = True
+
+        sm1_initial = sm1.initial
+        sm1_final = sm1.final
+
+        assert sm2.finish() == ("sm2", True)
+
+        assert not sm2.initial.is_active
+        assert sm2.final.is_active
+        assert sm2.finalized is True
+
+        assert sm1_initial.is_active
+        assert not sm1_final.is_active
+        assert sm1.finalized is False
+
+        assert sm1.initial.is_active
+        assert not sm1.final.is_active
+
+        assert sm1.finish() == ("sm1", True)
+
+        assert sm1.finalized is True
+        assert not sm1.initial.is_active
+        assert sm1.final.is_active
+
+    def test_instance_states_and_transitions_are_isolated(self, simple_sm_cls):
+        sm1 = simple_sm_cls("sm1")
+
+        assert sm1.initial == simple_sm_cls.initial
+        assert sm1.initial is not simple_sm_cls.initial
+
+        assert repr(sm1.initial.transitions[0]) == repr(
+            simple_sm_cls.initial.transitions[0]
+        )
+        assert sm1.initial.transitions[0] is not simple_sm_cls.initial.transitions[0]