test: run StateChart tests on both sync and async engines

Add SMRunner fixture parametrized over sync/async to conftest.py.
Engine-dependent tests (53) now run on both engines via sm_runner,
producing 108 test cases total. Definition-only tests (2) remain sync.

Author: fgmacedo

tests/conftest.py

@@ -226,3 +226,64 @@ def engine(request):
         return SyncEngine
     else:
         return AsyncEngine
+
+
+class _AsyncListener:
+    """No-op async listener that triggers AsyncEngine selection."""
+
+    async def on_enter_state(self, **kwargs):
+        pass
+
+
+class SMRunner:
+    """Helper for running state machine tests on both sync and async engines.
+
+    Usage in tests::
+
+        async def test_something(self, sm_runner):
+            sm = await sm_runner.start(MyStateChart)
+            await sm_runner.send(sm, "some_event")
+            assert "expected_state" in sm.configuration_values
+    """
+
+    def __init__(self, is_async: bool):
+        self.is_async = is_async
+
+    async def start(self, cls, **kwargs):
+        """Create and activate a state machine instance."""
+        from inspect import isawaitable
+
+        if self.is_async:
+            listeners = list(kwargs.pop("listeners", []))
+            listeners.append(_AsyncListener())
+            sm = cls(listeners=listeners, **kwargs)
+            result = sm.activate_initial_state()
+            if isawaitable(result):
+                await result
+        else:
+            sm = cls(**kwargs)
+        return sm
+
+    async def send(self, sm, event, **kwargs):
+        """Send an event to the state machine."""
+        from inspect import isawaitable
+
+        result = sm.send(event, **kwargs)
+        if isawaitable(result):
+            return await result
+        return result
+
+    async def processing_loop(self, sm):
+        """Run the processing loop (for delayed event tests)."""
+        from inspect import isawaitable
+
+        result = sm._processing_loop()
+        if isawaitable(result):
+            return await result
+        return result
+
+
+@pytest.fixture(params=["sync", "async"])
+def sm_runner(request):
+    """Fixture that runs tests on both sync and async engines."""
+    return SMRunner(is_async=request.param == "async")

tests/test_statechart_compound.py

@@ -16,7 +16,7 @@
 
 @pytest.mark.timeout(5)
 class TestCompoundStates:
-    def test_enter_compound_activates_initial_child(self):
+    async def test_enter_compound_activates_initial_child(self, sm_runner):
         """Entering a compound activates both parent and the initial child."""
 
         class ShireToRivendell(StateChart):
@@ -29,10 +29,10 @@ class shire(State.Compound):
             road = State(final=True)
             depart = shire.to(road)
 
-        sm = ShireToRivendell()
+        sm = await sm_runner.start(ShireToRivendell)
         assert {"shire", "bag_end"} == set(sm.configuration_values)
 
-    def test_transition_within_compound(self):
+    async def test_transition_within_compound(self, sm_runner):
         """Inner state changes while parent stays active."""
 
         class ShireToRivendell(StateChart):
@@ -45,13 +45,13 @@ class shire(State.Compound):
             road = State(final=True)
             depart = shire.to(road)
 
-        sm = ShireToRivendell()
-        sm.send("visit_pub")
+        sm = await sm_runner.start(ShireToRivendell)
+        await sm_runner.send(sm, "visit_pub")
         assert "shire" in sm.configuration_values
         assert "green_dragon" in sm.configuration_values
         assert "bag_end" not in sm.configuration_values
 
-    def test_exit_compound_removes_all_descendants(self):
+    async def test_exit_compound_removes_all_descendants(self, sm_runner):
         """Leaving a compound removes the parent and all children."""
 
         class ShireToRivendell(StateChart):
@@ -64,11 +64,11 @@ class shire(State.Compound):
             road = State(final=True)
             depart = shire.to(road)
 
-        sm = ShireToRivendell()
-        sm.send("depart")
+        sm = await sm_runner.start(ShireToRivendell)
+        await sm_runner.send(sm, "depart")
         assert {"road"} == set(sm.configuration_values)
 
-    def test_nested_compound_two_levels(self):
+    async def test_nested_compound_two_levels(self, sm_runner):
         """Three-level nesting: outer > middle > leaf."""
 
         class MoriaExpedition(StateChart):
@@ -83,10 +83,10 @@ class upper_halls(State.Compound):
                 depths = State(final=True)
                 descend = upper_halls.to(depths)
 
-        sm = MoriaExpedition()
+        sm = await sm_runner.start(MoriaExpedition)
         assert {"moria", "upper_halls", "entrance"} == set(sm.configuration_values)
 
-    def test_transition_from_inner_to_outer(self):
+    async def test_transition_from_inner_to_outer(self, sm_runner):
         """A deep child can transition to an outer state."""
 
         class MoriaExpedition(StateChart):
@@ -104,11 +104,11 @@ class upper_halls(State.Compound):
             daylight = State(final=True)
             escape = moria.to(daylight)
 
-        sm = MoriaExpedition()
-        sm.send("escape")
+        sm = await sm_runner.start(MoriaExpedition)
+        await sm_runner.send(sm, "escape")
         assert {"daylight"} == set(sm.configuration_values)
 
-    def test_cross_compound_transition(self):
+    async def test_cross_compound_transition(self, sm_runner):
         """Transition from one compound to another removes old children."""
 
         class MiddleEarthJourney(StateChart):
@@ -135,17 +135,17 @@ class lothlorien(State.Compound):
             march_to_moria = rivendell.to(moria)
             march_to_lorien = moria.to(lothlorien)
 
-        sm = MiddleEarthJourney()
+        sm = await sm_runner.start(MiddleEarthJourney)
         assert "rivendell" in sm.configuration_values
         assert "council" in sm.configuration_values
 
-        sm.send("march_to_moria")
+        await sm_runner.send(sm, "march_to_moria")
         assert "moria" in sm.configuration_values
         assert "gates" in sm.configuration_values
         assert "rivendell" not in sm.configuration_values
         assert "council" not in sm.configuration_values
 
-    def test_enter_compound_lands_on_initial(self):
+    async def test_enter_compound_lands_on_initial(self, sm_runner):
         """Entering a compound from outside lands on the initial child."""
 
         class MiddleEarthJourney(StateChart):
@@ -165,13 +165,12 @@ class moria(State.Compound):
 
             march_to_moria = rivendell.to(moria)
 
-        sm = MiddleEarthJourney()
-        sm.send("march_to_moria")
-        # Should land on the initial child 'gates'
+        sm = await sm_runner.start(MiddleEarthJourney)
+        await sm_runner.send(sm, "march_to_moria")
         assert "gates" in sm.configuration_values
         assert "moria" in sm.configuration_values
 
-    def test_final_child_fires_done_state(self):
+    async def test_final_child_fires_done_state(self, sm_runner):
         """Reaching a final child triggers done.state.{parent_id}."""
 
         class QuestForErebor(StateChart):
@@ -186,13 +185,13 @@ class lonely_mountain(State.Compound):
                 lonely_mountain.to(victory), id="done.state.lonely_mountain"
             )
 
-        sm = QuestForErebor()
+        sm = await sm_runner.start(QuestForErebor)
         assert "approach" in sm.configuration_values
 
-        sm.send("enter_mountain")
+        await sm_runner.send(sm, "enter_mountain")
         assert {"victory"} == set(sm.configuration_values)
 
-    def test_multiple_compound_sequential_traversal(self):
+    async def test_multiple_compound_sequential_traversal(self, sm_runner):
         """Traverse all three compounds sequentially."""
 
         class MiddleEarthJourney(StateChart):
@@ -219,16 +218,16 @@ class lothlorien(State.Compound):
             march_to_moria = rivendell.to(moria)
             march_to_lorien = moria.to(lothlorien)
 
-        sm = MiddleEarthJourney()
-        sm.send("march_to_moria")
+        sm = await sm_runner.start(MiddleEarthJourney)
+        await sm_runner.send(sm, "march_to_moria")
         assert "moria" in sm.configuration_values
 
-        sm.send("march_to_lorien")
+        await sm_runner.send(sm, "march_to_lorien")
         assert "lothlorien" in sm.configuration_values
         assert "mirror" in sm.configuration_values
         assert "moria" not in sm.configuration_values
 
-    def test_entry_exit_action_ordering(self):
+    async def test_entry_exit_action_ordering(self, sm_runner):
         """on_exit fires before on_enter (verified via log)."""
         log = []
 
@@ -251,11 +250,11 @@ def on_exit_realm(self):
             def on_enter_outside(self):
                 log.append("enter_outside")
 
-        sm = ActionOrderTracker()
-        sm.send("leave")
+        sm = await sm_runner.start(ActionOrderTracker)
+        await sm_runner.send(sm, "leave")
         assert log == ["exit_day", "exit_realm", "enter_outside"]
 
-    def test_callbacks_inside_compound_class(self):
+    async def test_callbacks_inside_compound_class(self, sm_runner):
         """Methods defined inside the State.Compound class body are discovered."""
         log = []
 
@@ -272,8 +271,8 @@ def on_enter_troubled(self):
             end = State(final=True)
             conclude = realm.to(end)
 
-        sm = CallbackDiscovery()
-        sm.send("darken")
+        sm = await sm_runner.start(CallbackDiscovery)
+        await sm_runner.send(sm, "darken")
         assert log == ["entered troubled times"]
 
     def test_compound_state_name_attribute(self):

tests/test_statechart_delayed.py

@@ -7,7 +7,7 @@
 Theme: Beacons of Gondor — signal fires propagate with timing.
 """
 
-import time
+import asyncio
 
 import pytest
 from statemachine.event import BoundEvent
@@ -19,7 +19,7 @@
 
 @pytest.mark.timeout(10)
 class TestDelayedEvents:
-    def test_delayed_event_fires_after_delay(self):
+    async def test_delayed_event_fires_after_delay(self, sm_runner):
         """Queuing a delayed event does not fire immediately; processing after delay does."""
 
         class BeaconsOfGondor(StateChart):
@@ -30,8 +30,8 @@ class BeaconsOfGondor(StateChart):
             light_first = dark.to(first_lit)
             light_all = first_lit.to(all_lit)
 
-        sm = BeaconsOfGondor()
-        sm.send("light_first")
+        sm = await sm_runner.start(BeaconsOfGondor)
+        await sm_runner.send(sm, "light_first")
         assert "first_lit" in sm.configuration_values
 
         # Queue the event with delay without triggering the processing loop
@@ -41,11 +41,11 @@ class BeaconsOfGondor(StateChart):
         # Not yet processed
         assert "first_lit" in sm.configuration_values
 
-        time.sleep(0.1)
-        sm._processing_loop()
+        await asyncio.sleep(0.1)
+        await sm_runner.processing_loop(sm)
         assert "all_lit" in sm.configuration_values
 
-    def test_cancel_delayed_event(self):
+    async def test_cancel_delayed_event(self, sm_runner):
         """Cancelled delayed events do not fire."""
 
         class BeaconsOfGondor(StateChart):
@@ -54,18 +54,18 @@ class BeaconsOfGondor(StateChart):
 
             light = dark.to(lit)
 
-        sm = BeaconsOfGondor()
+        sm = await sm_runner.start(BeaconsOfGondor)
         # Queue delayed event
         event = BoundEvent(id="light", name="Light", delay=500, _sm=sm)
         event.put(send_id="beacon_signal")
 
         sm.cancel_event("beacon_signal")
 
-        time.sleep(0.1)
-        sm._processing_loop()
+        await asyncio.sleep(0.1)
+        await sm_runner.processing_loop(sm)
         assert "dark" in sm.configuration_values
 
-    def test_zero_delay_fires_immediately(self):
+    async def test_zero_delay_fires_immediately(self, sm_runner):
         """delay=0 fires immediately."""
 
         class BeaconsOfGondor(StateChart):
@@ -74,11 +74,11 @@ class BeaconsOfGondor(StateChart):
 
             light = dark.to(lit)
 
-        sm = BeaconsOfGondor()
-        sm.send("light", delay=0)
+        sm = await sm_runner.start(BeaconsOfGondor)
+        await sm_runner.send(sm, "light", delay=0)
         assert "lit" in sm.configuration_values
 
-    def test_delayed_event_on_event_definition(self):
+    async def test_delayed_event_on_event_definition(self, sm_runner):
         """Event(transitions, delay=100) syntax queues with a delay."""
 
         class BeaconsOfGondor(StateChart):
@@ -87,14 +87,14 @@ class BeaconsOfGondor(StateChart):
 
             light = Event(dark.to(lit), delay=50)
 
-        sm = BeaconsOfGondor()
+        sm = await sm_runner.start(BeaconsOfGondor)
         # Queue via BoundEvent.put() to avoid blocking in processing_loop
         event = BoundEvent(id="light", name="Light", delay=50, _sm=sm)
         event.put()
 
         # Not yet processed
         assert "dark" in sm.configuration_values
 
-        time.sleep(0.1)
-        sm._processing_loop()
+        await asyncio.sleep(0.1)
+        await sm_runner.processing_loop(sm)
         assert "lit" in sm.configuration_values