tests: Improved compound tests for syntax

Author: fgmacedo

statemachine/factory.py

@@ -30,15 +30,21 @@ def __init__(cls, name, bases, attrs):
     def _set_special_states(cls):
         if not cls.states:
             return
-        initials = [s for s in cls.states if s.initial and not s.parent]
-        if len(initials) != 1:
+        initials = [s for s in cls.states if s.initial]
+        parallels = [s.id for s in cls.states if s.parallel]
+        root_only_has_parallels = len(cls.states) == len(parallels)
+        if len(initials) != 1 and not root_only_has_parallels:
             raise InvalidDefinition(
                 _(
                     "There should be one and only one initial state. "
                     "Your currently have these: {0}"
                 ).format(", ".join(s.id for s in initials))
             )
-        cls.initial_state = initials[0]
+        if root_only_has_parallels:
+            # TODO: Temp, whe should fix initial, and current state design
+            cls.initial_state = cls.states[0]
+        else:
+            cls.initial_state = initials[0]
         cls.final_states = [state for state in cls.states if state.final]
 
     def _disconnected_states(cls, starting_state):

statemachine/state.py

@@ -1,6 +1,6 @@
+from copy import deepcopy
 from typing import Any
 from typing import TypeAlias
-from copy import deepcopy
 
 from .callbacks import Callbacks
 from .exceptions import StateMachineError

tests/examples/microwave_inheritance_machine.py

@@ -38,11 +38,11 @@
 
 
 class MicroWave(StateMachine):
-    class oven(State.Builder, name="Oven", initial=True, parallel=True):
-        class engine(State.Builder, name="Engine"):
+    class oven(State.Builder, name="Microwave oven", parallel=True):
+        class engine(State.Builder):
             off = State("Off", initial=True)
 
-            class on(State.Builder, name="On"):
+            class on(State.Builder):
                 idle = State("Idle", initial=True)
                 cooking = State("Cooking")
 
@@ -55,9 +55,9 @@ class on(State.Builder, name="On"):
             turn_on = off.to(on)
             on.to(off, cond="cook_time_is_over")  # eventless transition
 
-        class door(State.Builder, name="Door"):
-            closed = State("Closed", initial=True)
-            open = State("Open")
+        class door(State.Builder):
+            closed = State(initial=True)
+            open = State()
 
             door_open = closed.to(open)
             door_close = open.to(closed)

tests/test_callbacks_isolation.py

@@ -17,7 +17,7 @@ def __init__(self, name):
             self.name = name
             self.can_finish = False
             self.finalized = False
-            super(TestStateMachine, self).__init__()
+            super().__init__()
 
         def do_finish(self):
             return self.name, self.can_finish

tests/test_compound.py

@@ -1,33 +1,68 @@
 import pytest
 
 from statemachine import State
-from statemachine import StateMachine
 
 
 @pytest.fixture()
-def compound_engine_cls():
-    class TestMachine(StateMachine):
-        class engine(State.Builder, name="Engine", initial=True):
-            off = State("Off", initial=True)
-            on = State("On")
+def microwave_cls():
+    from tests.examples.microwave_inheritance_machine import MicroWave
 
-            turn_on = off.to(on)
-            turn_off = on.to(off)
+    return MicroWave
 
-    return TestMachine
+
+def assert_state(s, name, initial=False, final=False, parallel=False, substates=None):
+    if substates is None:
+        substates = []
+
+    assert isinstance(s, State)
+    assert s.name == name
+    assert s.initial is initial
+    assert s.final is final
+    assert s.parallel is parallel
+    assert isinstance(s, State)
+    assert set(s.substates) == set(substates)
 
 
 class TestNestedDeclarations:
-    def test_capture_constructor_arguments(self, compound_engine_cls):
-        sm = compound_engine_cls()
-        assert isinstance(sm.engine, State)
-        assert sm.engine.name == "Engine"
-        assert sm.engine.initial is True
-
-    def test_list_children_states(self, compound_engine_cls):
-        sm = compound_engine_cls()
-        assert [s.id for s in sm.engine.substates] == ["off", "on"]
-
-    def test_list_events(self, compound_engine_cls):
-        sm = compound_engine_cls()
-        assert [e.name for e in sm.events] == ["turn_on", "turn_off"]
+    def test_capture_constructor_arguments(self, microwave_cls):
+        sm = microwave_cls()
+
+        assert_state(
+            sm.oven,
+            "Microwave oven",
+            parallel=True,
+            substates=[sm.oven.engine, sm.oven.door],
+        )
+        assert_state(
+            sm.oven.engine,
+            "Engine",
+            initial=False,
+            substates=[sm.oven.engine.on, sm.oven.engine.off],
+        )
+        assert_state(sm.oven.engine.off, "Off", initial=True)
+        assert_state(
+            sm.oven.engine.on,
+            "On",
+            substates=[sm.oven.engine.on.idle, sm.oven.engine.on.cooking],
+        )
+        assert_state(
+            sm.oven.door,
+            "Door",
+            initial=False,
+            substates=[sm.oven.door.closed, sm.oven.door.open],
+        )
+        assert_state(sm.oven.door.closed, "Closed", initial=True)
+        assert_state(sm.oven.door.open, "Open")
+
+    def test_list_children_states(self, microwave_cls):
+        sm = microwave_cls()
+        assert [s.id for s in sm.oven.engine.substates] == ["off", "on"]
+
+    def test_list_events(self, microwave_cls):
+        sm = microwave_cls()
+        assert [e.name for e in sm.events] == [
+            "turn_on",
+            "turn_off",
+            "door_open",
+            "door_close",
+        ]