refactor(tests): migrate main test files from StateMachine to StateChart

- test_statemachine.py: all classes → StateChart, current_state → is_active
- test_copy.py: all classes → StateChart, current_state → is_active
- test_async.py: all classes → StateChart with explicit flags where needed
  (allow_event_without_transition=False, error_on_execution=False)

Author: fgmacedo

tests/test_async.py

@@ -6,12 +6,13 @@
 
 from statemachine import State
 from statemachine import StateChart
-from statemachine import StateMachine
 
 
 @pytest.fixture()
 def async_order_control_machine():  # noqa: C901
-    class OrderControl(StateMachine):
+    class OrderControl(StateChart):
+        allow_event_without_transition = False
+
         waiting_for_payment = State(initial=True)
         processing = State()
         shipping = State()
@@ -98,9 +99,11 @@ def test_async_state_from_sync_context(async_order_control_machine):
     assert sm.completed.is_active
 
 
-class AsyncConditionExpressionMachine(StateMachine):
+class AsyncConditionExpressionMachine(StateChart):
     """Regression test for issue #535: async conditions in boolean expressions."""
 
+    allow_event_without_transition = False
+
     s1 = State(initial=True)
 
     go_not = s1.to.itself(cond="not cond_false")
@@ -190,17 +193,21 @@ async def test_async_state_should_be_initialized(async_order_control_machine):
     """
 
     sm = async_order_control_machine()
-    with pytest.raises(
-        InvalidStateValue,
-        match=re.escape(
-            r"There's no current state set. In async code, "
-            r"did you activate the initial state? (e.g., `await sm.activate_initial_state()`)"
-        ),
-    ):
-        assert sm.current_state == sm.waiting_for_payment
+    import warnings
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        with pytest.raises(
+            InvalidStateValue,
+            match=re.escape(
+                r"There's no current state set. In async code, "
+                r"did you activate the initial state? (e.g., `await sm.activate_initial_state()`)"
+            ),
+        ):
+            sm.current_state  # noqa: B018
 
     await sm.activate_initial_state()
-    assert sm.current_state == sm.waiting_for_payment
+    assert sm.waiting_for_payment.is_active
 
 
 @pytest.mark.timeout(5)
@@ -303,7 +310,9 @@ def after_go(self, **kwargs):
 async def test_async_runtime_error_in_after_without_error_on_execution():
     """RuntimeError in async after callback without error_on_execution propagates."""
 
-    class SM(StateMachine):
+    class SM(StateChart):
+        error_on_execution = False
+
         s1 = State(initial=True)
         s2 = State(final=True)
 
@@ -384,7 +393,9 @@ async def after_go(self, **kwargs):
 async def test_async_engine_runtime_error_in_after_without_error_on_execution_propagates():
     """AsyncEngine: RuntimeError in async after callback without error_on_execution raises."""
 
-    class SM(StateMachine):
+    class SM(StateChart):
+        error_on_execution = False
+
         s1 = State(initial=True)
         s2 = State(final=True)
 
@@ -403,7 +414,7 @@ async def after_go(self, **kwargs):
 async def test_async_engine_start_noop_when_already_initialized():
     """BaseEngine.start() is a no-op when state machine is already initialized."""
 
-    class SM(StateMachine):
+    class SM(StateChart):
         s1 = State(initial=True)
         s2 = State(final=True)
 
@@ -422,7 +433,7 @@ async def on_go(
 
 class TestAsyncEnabledEvents:
     async def test_passing_async_condition(self):
-        class MyMachine(StateMachine):
+        class MyMachine(StateChart):
             s0 = State(initial=True)
             s1 = State(final=True)
 
@@ -436,7 +447,7 @@ async def is_ready(self):
         assert [e.id for e in await sm.enabled_events()] == ["go"]
 
     async def test_failing_async_condition(self):
-        class MyMachine(StateMachine):
+        class MyMachine(StateChart):
             s0 = State(initial=True)
             s1 = State(final=True)
 
@@ -450,7 +461,7 @@ async def is_ready(self):
         assert await sm.enabled_events() == []
 
     async def test_kwargs_forwarded_to_async_conditions(self):
-        class MyMachine(StateMachine):
+        class MyMachine(StateChart):
             s0 = State(initial=True)
             s1 = State(final=True)
 
@@ -465,7 +476,7 @@ async def check_value(self, value=0):
         assert [e.id for e in await sm.enabled_events(value=20)] == ["go"]
 
     async def test_async_condition_exception_treated_as_enabled(self):
-        class MyMachine(StateMachine):
+        class MyMachine(StateChart):
             s0 = State(initial=True)
             s1 = State(final=True)
 
@@ -481,7 +492,7 @@ async def bad_cond(self):
     async def test_duplicate_event_across_transitions_deduplicated(self):
         """Same event on multiple passing transitions appears only once."""
 
-        class MyMachine(StateMachine):
+        class MyMachine(StateChart):
             s0 = State(initial=True)
             s1 = State()
             s2 = State(final=True)
@@ -501,7 +512,7 @@ async def cond_b(self):
         assert len(ids) == 1
 
     async def test_mixed_enabled_and_disabled_async(self):
-        class MyMachine(StateMachine):
+        class MyMachine(StateChart):
             s0 = State(initial=True)
             s1 = State()
             s2 = State(final=True)

tests/test_copy.py

@@ -9,7 +9,7 @@
 from statemachine.states import States
 
 from statemachine import State
-from statemachine import StateMachine
+from statemachine import StateChart
 
 logger = logging.getLogger(__name__)
 
@@ -30,7 +30,7 @@ class GameStates(str, Enum):
     GAME_END = auto()
 
 
-class GameStateMachine(StateMachine):
+class GameStateMachine(StateChart):
     s = States.from_enum(GameStates, initial=GameStates.GAME_START)
 
     play = s.GAME_START.to(s.GAME_PLAYING)
@@ -44,7 +44,7 @@ def game_is_over(self) -> bool:
     advance_round = end_game | s.TURN_END.to(s.GAME_END)
 
 
-class MyStateMachine(StateMachine):
+class MyStateMachine(StateChart):
     created = State(initial=True)
     started = State()
 
@@ -56,7 +56,7 @@ def __init__(self):
         self.value = [1, 2, 3]
 
 
-class MySM(StateMachine):
+class MySM(StateChart):
     draft = State("Draft", initial=True, value="draft")
     published = State("Published", value="published", final=True)
 
@@ -89,11 +89,11 @@ def test_copy(copy_method):
 
     assert sm.model is not sm2.model
     assert sm.model.name == sm2.model.name
-    assert sm2.current_state == sm.current_state
+    assert sm2.draft.is_active
 
     sm2.model.let_me_be_visible = True
     sm2.send("publish")
-    assert sm2.current_state == sm.published
+    assert sm2.published.is_active
 
 
 def test_copy_with_listeners(copy_method):
@@ -120,16 +120,16 @@ def test_copy_with_listeners(copy_method):
         listener.let_me_be_visible = True
 
     sm2.send("publish")
-    assert sm2.current_state == sm1.published
+    assert sm2.published.is_active
 
 
 def test_copy_with_enum(copy_method):
     sm = GameStateMachine()
     sm.play()
-    assert sm.current_state == GameStateMachine.GAME_PLAYING
+    assert sm.GAME_PLAYING.is_active
 
     sm2 = copy_method(sm)
-    assert sm2.current_state == GameStateMachine.GAME_PLAYING
+    assert sm2.GAME_PLAYING.is_active
 
 
 def test_copy_with_custom_init_and_vars(copy_method):
@@ -139,10 +139,10 @@ def test_copy_with_custom_init_and_vars(copy_method):
     sm2 = copy_method(sm)
     assert sm2.custom == 1
     assert sm2.value == [1, 2, 3]
-    assert sm2.current_state == MyStateMachine.started
+    assert sm2.started.is_active
 
 
-class AsyncTrafficLightMachine(StateMachine):
+class AsyncTrafficLightMachine(StateChart):
     green = State(initial=True)
     yellow = State()
     red = State()
@@ -164,9 +164,9 @@ def test_copy_async_statemachine_before_activation(copy_method):
 
     async def verify():
         await sm_copy.activate_initial_state()
-        assert sm_copy.current_state == AsyncTrafficLightMachine.green
+        assert sm_copy.green.is_active
         await sm_copy.cycle()
-        assert sm_copy.current_state == AsyncTrafficLightMachine.yellow
+        assert sm_copy.yellow.is_active
 
     asyncio.run(verify())
 
@@ -178,13 +178,13 @@ async def setup_and_verify():
         sm = AsyncTrafficLightMachine()
         await sm.activate_initial_state()
         await sm.cycle()
-        assert sm.current_state == AsyncTrafficLightMachine.yellow
+        assert sm.yellow.is_active
 
         sm_copy = copy_method(sm)
 
         await sm_copy.activate_initial_state()
-        assert sm_copy.current_state == AsyncTrafficLightMachine.yellow
+        assert sm_copy.yellow.is_active
         await sm_copy.cycle()
-        assert sm_copy.current_state == AsyncTrafficLightMachine.red
+        assert sm_copy.red.is_active
 
     asyncio.run(setup_and_verify())