chore: Adding test to cover scenario in #449 (#450)

* chore: Adding test to cover scenario in #449
* refac: Removing transition.execute
* refac: Removing trigger callback in favor of trigger_data

Author: fgmacedo

statemachine/event.py

@@ -1,11 +1,8 @@
-from functools import partial
 from typing import TYPE_CHECKING
 
 from statemachine.utils import run_async_from_sync
 
-from .event_data import EventData
 from .event_data import TriggerData
-from .exceptions import TransitionNotAllowed
 
 if TYPE_CHECKING:
     from .statemachine import StateMachine
@@ -25,35 +22,16 @@ async def trigger(self, machine: "StateMachine", *args, **kwargs):
             args=args,
             kwargs=kwargs,
         )
-        trigger_wrapper = partial(self._trigger, trigger_data=trigger_data)
 
-        return await machine._process(trigger_wrapper)
-
-    async def _trigger(self, trigger_data: TriggerData):
-        event_data = None
-        await trigger_data.machine._ensure_is_initialized()
-
-        state = trigger_data.machine.current_state
-        for transition in state.transitions:
-            if not transition.match(trigger_data.event):
-                continue
-
-            event_data = EventData(trigger_data=trigger_data, transition=transition)
-            if await transition.execute(event_data):
-                event_data.executed = True
-                break
-        else:
-            if not trigger_data.machine.allow_event_without_transition:
-                raise TransitionNotAllowed(trigger_data.event, state)
-
-        return event_data.result if event_data else None
+        return await machine._process(trigger_data)
 
 
 def trigger_event_factory(event_instance: Event):
     """Build a method that sends specific `event` to the machine"""
 
     def trigger_event(self, *args, **kwargs):
-        return run_async_from_sync(event_instance.trigger(self, *args, **kwargs))
+        coro = event_instance.trigger(self, *args, **kwargs)
+        return run_async_from_sync(coro)
 
     trigger_event.name = event_instance.name  # type: ignore[attr-defined]
     trigger_event.identifier = event_instance.name  # type: ignore[attr-defined]

statemachine/event_data.py

@@ -53,10 +53,7 @@ def __post_init__(self):
         self.state = self.transition.source
         self.source = self.transition.source
         self.target = self.transition.target
-
-    @property
-    def machine(self):
-        return self.trigger_data.machine
+        self.machine = self.trigger_data.machine
 
     @property
     def event(self):

statemachine/events.py

@@ -27,5 +27,5 @@ def add(self, events):
 
         return self
 
-    def match(self, event):
-        return any(t == event for t in self)
+    def match(self, event: str):
+        return any(e == event for e in self)

statemachine/statemachine.py

@@ -287,7 +287,32 @@ def allowed_events(self):
         """List of the current allowed events."""
         return [getattr(self, event) for event in self.current_state.transitions.unique_events]
 
-    async def _process(self, trigger):
+    async def _trigger(self, trigger_data: TriggerData):
+        event_data = None
+        await self._ensure_is_initialized()
+
+        state = self.current_state
+        for transition in state.transitions:
+            if not transition.match(trigger_data.event):
+                continue
+
+            event_data = EventData(trigger_data=trigger_data, transition=transition)
+            args, kwargs = event_data.args, event_data.extended_kwargs
+            await self._get_callbacks(transition.validators.key).call(*args, **kwargs)
+            if not await self._get_callbacks(transition.cond.key).all(*args, **kwargs):
+                continue
+
+            result = await self._activate(event_data)
+            event_data.result = result
+            event_data.executed = True
+            break
+        else:
+            if not self.allow_event_without_transition:
+                raise TransitionNotAllowed(trigger_data.event, state)
+
+        return event_data.result if event_data else None
+
+    async def _process(self, trigger_data: TriggerData):
         """Process event triggers.
 
         The simplest implementation is the non-RTC (synchronous),
@@ -308,11 +333,11 @@ async def _process(self, trigger):
         """
         if not self.__rtc:
             # The machine is in "synchronous" mode
-            return await trigger()
+            return await self._trigger(trigger_data)
 
         # The machine is in "queued" mode
         # Add the trigger to queue and start processing in a loop.
-        self._external_queue.append(trigger)
+        self._external_queue.append(trigger_data)
 
         # We make sure that only the first event enters the processing critical section,
         # next events will only be put on the queue and processed by the same loop.
@@ -332,9 +357,9 @@ async def _processing_loop(self):
         first_result = sentinel
         try:
             while self._external_queue:
-                trigger = self._external_queue.popleft()
+                trigger_data = self._external_queue.popleft()
                 try:
-                    result = await trigger()
+                    result = await self._trigger(trigger_data)
                     if first_result is sentinel:
                         first_result = result
                 except Exception:
@@ -347,32 +372,24 @@ async def _processing_loop(self):
         return first_result if first_result is not sentinel else None
 
     async def _activate(self, event_data: EventData):
+        args, kwargs = event_data.args, event_data.extended_kwargs
         transition = event_data.transition
         source = event_data.state
         target = transition.target
 
-        result = await self._get_callbacks(transition.before.key).call(
-            *event_data.args, **event_data.extended_kwargs
-        )
+        result = await self._get_callbacks(transition.before.key).call(*args, **kwargs)
         if source is not None and not transition.internal:
-            await self._get_callbacks(source.exit.key).call(
-                *event_data.args, **event_data.extended_kwargs
-            )
+            await self._get_callbacks(source.exit.key).call(*args, **kwargs)
 
-        result += await self._get_callbacks(transition.on.key).call(
-            *event_data.args, **event_data.extended_kwargs
-        )
+        result += await self._get_callbacks(transition.on.key).call(*args, **kwargs)
 
         self.current_state = target
         event_data.state = target
+        kwargs["state"] = target
 
         if not transition.internal:
-            await self._get_callbacks(target.enter.key).call(
-                *event_data.args, **event_data.extended_kwargs
-            )
-        await self._get_callbacks(transition.after.key).call(
-            *event_data.args, **event_data.extended_kwargs
-        )
+            await self._get_callbacks(target.enter.key).call(*args, **kwargs)
+        await self._get_callbacks(transition.after.key).call(*args, **kwargs)
 
         if len(result) == 0:
             result = None
@@ -392,7 +409,8 @@ def send(self, event: str, *args, **kwargs):
             See: :ref:`triggering events`.
 
         """
-        return run_async_from_sync(self.async_send(event, *args, **kwargs))
+        coro = self.async_send(event, *args, **kwargs)
+        return run_async_from_sync(coro)
 
     async def async_send(self, event: str, *args, **kwargs):
         """Send an :ref:`Event` to the state machine.

statemachine/transition.py

@@ -1,5 +1,3 @@
-from typing import TYPE_CHECKING
-
 from .callbacks import BoolCallbackSpec
 from .callbacks import CallbackGroup
 from .callbacks import CallbackPriority
@@ -8,9 +6,6 @@
 from .events import Events
 from .exceptions import InvalidDefinition
 
-if TYPE_CHECKING:
-    from .event_data import EventData
-
 
 class Transition:
     """A transition holds reference to the source and target state.
@@ -119,7 +114,7 @@ def _setup(self):
             is_convention=True,
         )
 
-    def match(self, event):
+    def match(self, event: str):
         return self._events.match(event)
 
     @property
@@ -132,14 +127,3 @@ def events(self):
 
     def add_event(self, value):
         self._events.add(value)
-
-    async def execute(self, event_data: "EventData"):
-        machine = event_data.machine
-        args, kwargs = event_data.args, event_data.extended_kwargs
-        await machine._get_callbacks(self.validators.key).call(*args, **kwargs)
-        if not await machine._get_callbacks(self.cond.key).all(*args, **kwargs):
-            return False
-
-        result = await machine._activate(event_data)
-        event_data.result = result
-        return True

statemachine/transition_list.py

@@ -1,25 +1,22 @@
-from typing import TYPE_CHECKING
 from typing import Callable
 from typing import Iterable
 from typing import List
 
+from .transition import Transition
 from .utils import ensure_iterable
 
-if TYPE_CHECKING:
-    from .transition import Transition
-
 
 class TransitionList:
     """A list-like container of :ref:`transitions` with callback functions."""
 
-    def __init__(self, transitions: "Iterable | None" = None):
+    def __init__(self, transitions: "Iterable[Transition] | None" = None):
         """
         Args:
             transitions: An iterable of `Transition` objects.
                 Defaults to `None`.
 
         """
-        self.transitions = list(transitions) if transitions else []
+        self.transitions: List[Transition] = list(transitions) if transitions else []
 
     def __repr__(self):
         """Return a string representation of the :ref:`TransitionList`."""
@@ -53,11 +50,12 @@ def add_transitions(self, transition: "Transition | TransitionList | Iterable"):
         transitions = ensure_iterable(transition)
 
         for transition in transitions:
+            assert isinstance(transition, Transition)  # makes mypy happy
             self.transitions.append(transition)
 
         return self
 
-    def __getitem__(self, index: int):
+    def __getitem__(self, index: int) -> "Transition":
         """Returns the :ref:`transition` at the specified ``index``.
 
         Args:

tests/testcases/issue449.md

@@ -0,0 +1,57 @@
+
+### Issue 449
+
+A StateMachine that exercises the example given on issue
+#[449](https://github.com/fgmacedo/python-statemachine/issues/449).
+
+
+
+```py
+>>> from statemachine import StateMachine, State
+
+>>> class ExampleStateMachine(StateMachine):
+...     initial = State(initial=True)
+...     second = State()
+...     third = State()
+...     fourth = State()
+...     final = State(final=True)
+...
+...     initial_to_second = initial.to(second)
+...     second_to_third = second.to(third)
+...     third_to_fourth = third.to(fourth)
+...     completion = fourth.to(final)
+...
+...     def on_enter_state(self, target: State, event: str):
+...         print(f"Entering state {target.id}. Event: {event}")
+...         if event == "initial_to_second":
+...             self.send("second_to_third")
+...         if event == "second_to_third":
+...             self.send("third_to_fourth")
+...         if event == "third_to_fourth":
+...             print("third_to_fourth on on_enter_state worked")
+
+
+```
+
+Exercise:
+
+
+```py
+>>> import pytest
+>>> pytest.xfail("This test is a regression on 2.3.0+ due to asyncio support.")
+>>> example = ExampleStateMachine()
+Entering state initial. Event: __initial__
+
+>>> print(example.current_state)
+Initial
+
+>>> example.send("initial_to_second") # this will call second_to_third and third_to_fourth
+Entering state second. Event: initial_to_second
+Entering state third. Event: second_to_third
+Entering state fourth. Event: third_to_fourth
+third_to_fourth on on_enter_state worked
+
+>>> print("My current state is", example.current_state)
+My current state is Fourth
+
+```