refactor(tests): migrate testcases, Django and SCXML tests to StateChart

Author: fgmacedo

tests/django_project/workflow/statemachines.py

@@ -1,11 +1,13 @@
 from statemachine.states import States
 
-from statemachine import StateMachine
+from statemachine import StateChart
 
 from .models import WorkflowSteps
 
 
-class WorfklowStateMachine(StateMachine):
+class WorfklowStateMachine(StateChart):
+    allow_event_without_transition = False
+
     _ = States.from_enum(WorkflowSteps, initial=WorkflowSteps.DRAFT, final=WorkflowSteps.PUBLISHED)
 
     publish = _.DRAFT.to(_.PUBLISHED, cond="is_active")

tests/scxml/test_microwave.py

@@ -40,7 +40,7 @@ def test_microwave_scxml():
     processor.parse_scxml("microwave", MICROWAVE_SCXML)
     sm = processor.start()
 
-    assert sm.current_state.id == "unplugged"
+    assert "unplugged" in sm.current_state_value
     sm.send("plug-in")
 
     assert "idle" in sm.current_state_value

tests/test_error_execution.py

@@ -4,7 +4,6 @@
 from statemachine import Event
 from statemachine import State
 from statemachine import StateChart
-from statemachine import StateMachine
 
 
 class ErrorInGuardSC(StateChart):
@@ -54,8 +53,10 @@ def bad_after(self):
         raise RuntimeError("after failed")
 
 
-class ErrorInGuardSM(StateMachine):
-    """StateMachine subclass: exceptions should propagate."""
+class ErrorInGuardSM(StateChart):
+    """StateChart subclass with error_on_execution=False: exceptions should propagate."""
+
+    error_on_execution = False
 
     initial = State("initial", initial=True)
 
@@ -65,10 +66,8 @@ def bad_guard(self):
         raise RuntimeError("guard failed")
 
 
-class ErrorInActionSMWithFlag(StateMachine):
-    """StateMachine subclass with error_on_execution = True."""
-
-    error_on_execution = True
+class ErrorInActionSMWithFlag(StateChart):
+    """StateChart subclass (error_on_execution = True by default)."""
 
     s1 = State("s1", initial=True)
     s2 = State("s2")
@@ -144,7 +143,7 @@ def test_exception_in_after_sends_error_execution_no_rollback():
 
 
 def test_statemachine_exception_propagates():
-    """StateMachine (error_on_execution=False) should propagate exceptions normally."""
+    """StateChart with error_on_execution=False should propagate exceptions normally."""
     sm = ErrorInGuardSM()
     assert sm.configuration == {sm.initial}
 
@@ -184,7 +183,7 @@ def test_error_in_error_handler_no_infinite_loop():
 
 
 def test_statemachine_with_error_on_execution_true():
-    """Custom StateMachine subclass with error_on_execution=True should catch errors."""
+    """StateChart (error_on_execution=True by default) should catch errors."""
     sm = ErrorInActionSMWithFlag()
     assert sm.configuration == {sm.s1}
 
@@ -496,11 +495,9 @@ def obsess(self):
         assert sm.configuration == {sm.betrayed}
 
     def test_statemachine_with_convention_and_flag(self):
-        """StateMachine with error_on_execution=True uses the error_ convention."""
-
-        class SarumanBetrayal(StateMachine):
-            error_on_execution = True
+        """StateChart (error_on_execution=True by default) uses the error_ convention."""
 
+        class SarumanBetrayal(StateChart):
             white_council = State("white_council", initial=True)
             orthanc = State("orthanc", final=True)
 
@@ -515,9 +512,11 @@ def betray(self):
         assert sm.configuration == {sm.orthanc}
 
     def test_statemachine_without_flag_propagates(self):
-        """StateMachine without error_on_execution=True propagates errors even with convention."""
+        """StateChart with error_on_execution=False propagates errors even with convention."""
+
+        class AragornSword(StateChart):
+            error_on_execution = False
 
-        class AragornSword(StateMachine):
             broken = State("broken", initial=True)
 
             reforge = broken.to(broken, on="attempt_reforge")
@@ -955,7 +954,9 @@ def after_go(self, **kwargs):
     def test_runtime_error_in_after_without_error_on_execution_propagates(self):
         """RuntimeError in 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)
 
@@ -989,7 +990,9 @@ def after_go(self, **kwargs):
     def test_runtime_error_in_microstep_without_error_on_execution(self):
         """RuntimeError in microstep without error_on_execution raises."""
 
-        class SM(StateMachine):
+        class SM(StateChart):
+            error_on_execution = False
+
             s1 = State(initial=True)
             s2 = State()
 
@@ -1007,7 +1010,9 @@ def on_enter_s2(self, **kwargs):
 def test_internal_queue_processes_raised_events():
     """Internal events raised during processing are handled."""
 
-    class SM(StateMachine):
+    class SM(StateChart):
+        error_on_execution = False
+
         s1 = State(initial=True)
         s2 = State()
         s3 = State(final=True)
@@ -1027,7 +1032,9 @@ def on_enter_s2(self, **kwargs):
 def test_engine_start_when_already_started():
     """start() is a no-op when state machine is already initialized."""
 
-    class SM(StateMachine):
+    class SM(StateChart):
+        error_on_execution = False
+
         s1 = State(initial=True)
         s2 = State(final=True)
 
@@ -1092,7 +1099,9 @@ def bad_action(self):
 def test_runtime_error_in_internal_event_propagates_without_error_on_execution():
     """RuntimeError in internal event propagates when error_on_execution is False."""
 
-    class SM(StateMachine):
+    class SM(StateChart):
+        error_on_execution = False
+
         s1 = State(initial=True)
         s2 = State()
         s3 = State()

tests/testcases/issue308.md

@@ -6,9 +6,9 @@ A StateMachine that exercises the example given on issue
 In this example, we share the transition list between events.
 
 ```py
->>> from statemachine import StateMachine, State
+>>> from statemachine import StateChart, State
 
->>> class TestSM(StateMachine):
+>>> class TestSM(StateChart):
 ...     state1 = State('s1', initial=True)
 ...     state2 = State('s2')
 ...     state3 = State('s3')
@@ -91,31 +91,37 @@ Example given:
 >>> m = TestSM()
 enter state1
 
->>> m.state1.is_active, m.state2.is_active, m.state3.is_active, m.state4.is_active, m.current_state ; _ = m.cycle()
-(True, False, False, False, State('s1', id='state1', value='state1', initial=True, final=False, parallel=False))
+>>> m.state1.is_active, m.state2.is_active, m.state3.is_active, m.state4.is_active, list(m.configuration_values)
+(True, False, False, False, ['state1'])
+
+>>> _ = m.cycle()
 before cycle
 exit state1
 on cycle
 enter state2
 after cycle
 
->>> m.state1.is_active, m.state2.is_active, m.state3.is_active, m.state4.is_active, m.current_state ; _ = m.cycle()
-(False, True, False, False, State('s2', id='state2', value='state2', initial=False, final=False, parallel=False))
+>>> m.state1.is_active, m.state2.is_active, m.state3.is_active, m.state4.is_active, list(m.configuration_values)
+(False, True, False, False, ['state2'])
+
+>>> _ = m.cycle()
 before cycle
 exit state2
 on cycle
 enter state3
 after cycle
 
->>> m.state1.is_active, m.state2.is_active, m.state3.is_active, m.state4.is_active, m.current_state ; _ = m.cycle()
-(False, False, True, False, State('s3', id='state3', value='state3', initial=False, final=False, parallel=False))
+>>> m.state1.is_active, m.state2.is_active, m.state3.is_active, m.state4.is_active, list(m.configuration_values)
+(False, False, True, False, ['state3'])
+
+>>> _ = m.cycle()
 before cycle
 exit state3
 on cycle
 enter state4
 after cycle
 
->>> m.state1.is_active, m.state2.is_active, m.state3.is_active, m.state4.is_active, m.current_state
-(False, False, False, True, State('s4', id='state4', value='state4', initial=False, final=True, parallel=False))
+>>> m.state1.is_active, m.state2.is_active, m.state3.is_active, m.state4.is_active, list(m.configuration_values)
+(False, False, False, True, ['state4'])
 
 ```

tests/testcases/issue384_multiple_observers.md

@@ -9,7 +9,7 @@ This works also as a regression test.
 
 ```py
 >>> from statemachine import State
->>> from statemachine import StateMachine
+>>> from statemachine import StateChart
 
 >>> class MyObs:
 ...     def on_move_car(self):
@@ -21,7 +21,7 @@ This works also as a regression test.
 ...
 
 
->>> class Car(StateMachine):
+>>> class Car(StateChart):
 ...     stopped = State(initial=True)
 ...     moving = State()
 ...

tests/testcases/issue449.md

@@ -7,9 +7,9 @@ A StateMachine that exercises the example given on issue
 
 
 ```py
->>> from statemachine import StateMachine, State
+>>> from statemachine import StateChart, State
 
->>> class ExampleStateMachine(StateMachine):
+>>> class ExampleStateMachine(StateChart):
 ...     initial = State(initial=True)
 ...     second = State()
 ...     third = State()
@@ -40,16 +40,16 @@ Exercise:
 >>> example = ExampleStateMachine()
 Entering state initial. Event: __initial__
 
->>> print(example.current_state)
-Initial
+>>> print(list(example.configuration_values))
+['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
+>>> print("My current state is", list(example.configuration_values))
+My current state is ['fourth']
 
 ```

tests/testcases/test_issue434.py

@@ -3,15 +3,17 @@
 import pytest
 
 from statemachine import State
-from statemachine import StateMachine
+from statemachine import StateChart
 
 
 class Model:
     def __init__(self, data: dict):
         self.data = data
 
 
-class DataCheckerMachine(StateMachine):
+class DataCheckerMachine(StateChart):
+    error_on_execution = False
+
     check_data = State(initial=True)
     data_good = State(final=True)
     data_bad = State(final=True)
@@ -50,24 +52,24 @@ def test_max_cycle_without_success(data_checker_machine):
     sm = data_checker_machine
     cycle_rate = 0.1
 
-    while not sm.current_state.final:
+    while not sm.is_terminated:
         sm.cycle()
         sleep(cycle_rate)
 
-    assert sm.current_state == sm.data_bad
+    assert sm.data_bad.is_active
     assert sm.cycle_count == 12
 
 
 def test_data_turns_good_mid_cycle(initial_data):
     sm = DataCheckerMachine(Model(initial_data))
     cycle_rate = 0.1
 
-    while not sm.current_state.final:
+    while not sm.is_terminated:
         sm.cycle()
         if sm.cycle_count == 5:
             print("Now data looks good!")
             sm.model.data["value"] = 20
         sleep(cycle_rate)
 
-    assert sm.current_state == sm.data_good
+    assert sm.data_good.is_active
     assert sm.cycle_count == 6  # Transition occurs at the 6th cycle

tests/testcases/test_issue480.py

@@ -12,10 +12,10 @@
 from unittest.mock import call
 
 from statemachine import State
-from statemachine import StateMachine
+from statemachine import StateChart
 
 
-class MyStateMachine(StateMachine):
+class MyStateMachine(StateChart):
     state_1 = State(initial=True)
     state_2 = State(final=True)
 
@@ -53,4 +53,4 @@ def test_initial_state_activation_handler():
     ]
 
     assert sm.mock.mock_calls == expected_calls
-    assert sm.current_state == sm.state_2
+    assert sm.state_2.is_active