test(experimental): add tests for generate_base_model and trigger decorators

Author: aleneum

tests/test_experimental.py

@@ -1,46 +1,193 @@
+from typing import TYPE_CHECKING
 from unittest import TestCase
+from types import ModuleType
 from unittest.mock import MagicMock
 
 from transitions import Machine
-from transitions.experimental.decoration import expect_override
+from transitions.experimental.typing import generate_base_model
+from transitions.experimental.decoration import trigger, with_trigger_decorator
+from transitions.extensions import HierarchicalMachine
+
+from .utils import Stuff
+
+if TYPE_CHECKING:
+    from transitions.core import MachineConfig
+    from typing import Type
+
+
+def import_code(code: str, name: str) -> ModuleType:
+    module = ModuleType(name)
+    exec(code, module.__dict__)
+    return module
 
 
 class TestExperimental(TestCase):
 
     def setUp(self) -> None:
-        self.machine_cls = Machine
-        return super().setUp()
+        self.machine_cls = Machine  # type: Type[Machine]
+        self.create_trigger_class()
 
-    def test_override_decorator(self):
-        b_mock = MagicMock()
-        c_mock = MagicMock()
+    def create_trigger_class(self):
+        @with_trigger_decorator
+        class TriggerMachine(self.machine_cls):  # type: ignore
+            pass
+
+        self.trigger_machine = TriggerMachine
+
+    def test_model_override(self):
 
         class Model:
 
-            @expect_override
-            def is_A(self) -> bool:
+            def trigger(self, name: str) -> bool:
                 raise RuntimeError("Should be overridden")
 
-            def is_B(self) -> bool:
-                b_mock()
-                return False
+            def is_A(self) -> bool:
+                raise RuntimeError("Should be overridden")
 
-            @expect_override
             def is_C(self) -> bool:
-                c_mock()
-                return False
+                raise RuntimeError("Should be overridden")
 
         model = Model()
-        machine = self.machine_cls(model, states=["A", "B"], initial="A")
+        machine = self.machine_cls(model, states=["A", "B"], initial="A", model_override=True)
         self.assertTrue(model.is_A())
-        self.assertTrue(model.to_B())
-        self.assertFalse(model.is_B())  # not overridden with convenience function
-        self.assertTrue(b_mock.called)
-        self.assertFalse(model.is_C())  # not overridden yet
-        self.assertTrue(c_mock.called)
+        with self.assertRaises(AttributeError):
+            model.to_B()  # type: ignore # Should not be assigned to model since its not declared
+        self.assertTrue(model.trigger("to_B"))
+        self.assertFalse(model.is_A())
+        with self.assertRaises(RuntimeError):
+            model.is_C()  # not overridden yet
         machine.add_state("C")
         self.assertFalse(model.is_C())  # now it is!
-        self.assertEqual(1, c_mock.call_count)   # call_count is not increased
-        self.assertTrue(model.to_C())
+        self.assertTrue(model.trigger("to_C"))
         self.assertTrue(model.is_C())
-        self.assertEqual(1, c_mock.call_count)
+
+    def test_generate_base_model(self):
+        simple_config = {
+            "states": ["A", "B"],
+            "transitions": [
+                ["go", "A", "B"],
+                ["back", "*", "A"]
+            ],
+            "initial": "A",
+            "model_override": True
+        }  # type: MachineConfig
+
+        mod = import_code(generate_base_model(simple_config), "base_module")
+        model = mod.BaseModel()
+        machine = self.machine_cls(model, **simple_config)
+        self.assertTrue(model.is_A())
+        self.assertTrue(model.go())
+        self.assertTrue(model.is_B())
+        self.assertTrue(model.back())
+        self.assertTrue(model.state == "A")
+        with self.assertRaises(AttributeError):
+            model.is_C()
+
+    def test_generate_base_model_callbacks(self):
+        simple_config = {
+            "states": ["A", "B"],
+            "transitions": [
+                ["go", "A", "B"],
+            ],
+            "initial": "A",
+            "model_override": True,
+            "before_state_change": "call_this"
+        }  # type: MachineConfig
+
+        mod = import_code(generate_base_model(simple_config), "base_module")
+        mock = MagicMock()
+
+        class Model(mod.BaseModel):  # type: ignore
+
+            @staticmethod
+            def call_this() -> None:
+                mock()
+
+        model = Model()
+        machine = self.machine_cls(model, **simple_config)
+        self.assertTrue(model.is_A())
+        self.assertTrue(model.go())
+        self.assertTrue(mock.called)
+
+    def test_generate_model_no_auto(self):
+        simple_config: MachineConfig = {
+            "states": ["A", "B"],
+            "auto_transitions": False,
+            "model_override": True,
+            "transitions": [
+                ["go", "A", "B"],
+                ["back", "*", "A"]
+            ],
+            "initial": "A"
+        }
+        mod = import_code(generate_base_model(simple_config), "base_module")
+        model = mod.BaseModel()
+        machine = self.machine_cls(model, **simple_config)
+        self.assertTrue(model.is_A())
+        self.assertTrue(model.go())
+        with self.assertRaises(AttributeError):
+            model.to_B()
+
+    def test_trigger_decorator(self):
+
+        class Model:
+
+            state: str = ""
+
+            def is_B(self) -> bool:
+                return False
+
+            @trigger(source="A", dest="B")
+            @trigger(source=["A", "B"], dest="C")
+            def go(self) -> bool:
+                raise RuntimeError("Should be overridden!")
+
+        model = Model()
+        machine = self.trigger_machine(model, states=["A", "B", "C"], initial="A")
+        self.assertEqual("A", model.state)
+        self.assertTrue(machine.is_state("A", model))
+        self.assertTrue(model.go())
+        with self.assertRaises(AttributeError):
+            model.is_A()  # type: ignore
+        self.assertEqual("B", model.state)
+        self.assertTrue(model.is_B())
+        self.assertTrue(model.go())
+        self.assertFalse(model.is_B())
+        self.assertEqual("C", model.state)
+
+    def test_trigger_decorator_complex(self):
+
+        class Model:
+
+            state: str = ""
+
+            def check_param(self, param: bool) -> bool:
+                return param
+
+            @trigger(source="A", dest="B")
+            @trigger(source="B", dest="C", unless=Stuff.this_passes)
+            @trigger(source="B", dest="A", conditions=Stuff.this_passes, unless=Stuff.this_fails)
+            def go(self) -> bool:
+                raise RuntimeError("Should be overridden")
+
+            @trigger(source="A", dest="B", conditions="check_param")
+            def event(self, param) -> bool:
+                raise RuntimeError("Should be overridden")
+
+        model = Model()
+        machine = self.trigger_machine(model, states=["A", "B"], initial="A")
+        self.assertTrue(model.go())
+        self.assertTrue(model.state == "B")
+        self.assertTrue(model.go())
+        self.assertTrue(model.state == "A")
+        self.assertFalse(model.event(param=False))
+        self.assertTrue(model.state == "A")
+        self.assertTrue(model.event(param=True))
+        self.assertTrue(model.state == "B")
+
+
+class TestHSMExperimental(TestExperimental):
+
+    def setUp(self):
+        self.machine_cls = HierarchicalMachine  # type: Type[HierarchicalMachine]
+        self.create_trigger_class()

tests/test_graphviz.py

@@ -314,7 +314,7 @@ def test_function_callbacks_annotation(self):
 class TestDiagramsNested(TestDiagrams):
 
     machine_cls = HierarchicalGraphMachine \
-        # type: Type[HierarchicalGraphMachine | LockedHierarchicalGraphMachine]
+        # type: Type[Union[HierarchicalGraphMachine, LockedHierarchicalGraphMachine]]
 
     def setUp(self):
         super(TestDiagramsNested, self).setUp()

transitions/core.pyi

@@ -18,8 +18,8 @@ ModelParameter = Union[Union[Literal['self'], Any], List[Union[Literal['self'],
 
 
 class MachineConfig(TypedDict, total=False):
-    states: list[StateIdentifier]
-    transitions: list[TransitionConfig]
+    states: List[StateIdentifier]
+    transitions: List[TransitionConfig]
     initial: str
     auto_transitions: bool
     send_event: bool

transitions/experimental/decoration.pyi

@@ -1,11 +1,11 @@
-from typing import Union, Type, Callable
+from typing import Union, Type, Callable, List, Optional
 from transitions.core import StateIdentifier, CallbacksArg, CallbackFunc, Machine
 
 
 def with_trigger_decorator(cls: Type[Machine]) -> Type[Machine]: ...
 
-def trigger(source: Union[StateIdentifier, list[StateIdentifier]],
-            dest: StateIdentifier | None = ...,
+def trigger(source: Union[StateIdentifier, List[StateIdentifier]],
+            dest: Optional[StateIdentifier] = ...,
             conditions: CallbacksArg = ..., unless: CallbacksArg = ...,
             before: CallbacksArg = ..., after: CallbacksArg = ...,
             prepare: CallbacksArg = ...) -> Callable[[CallbackFunc], CallbackFunc]: ...

transitions/experimental/typing.py

@@ -62,15 +62,15 @@ def generate_base_model(config):
             f"    def may_{trigger_name}(self) -> bool: {_placeholder_body}\n"
         )
 
-    extra_params = "event_data: EventData" if m.send_event else "*args: list[Any], **kwargs: dict[str, Any]"
+    extra_params = "event_data: EventData" if m.send_event else "*args: List[Any], **kwargs: Dict[str, Any]"
     for callback_name in callbacks:
         if isinstance(callback_name, str):
             callback_block += (f"    @abstractmethod\n"
-                               f"    def {callback_name}(self, {extra_params}) -> bool | None: ...\n")
+                               f"    def {callback_name}(self, {extra_params}) -> Optional[bool]: ...\n")
 
     template = f"""# autogenerated by transitions
 from abc import ABCMeta, abstractmethod
-from typing import Callable, ParamSpec, Union, Optional, Tuple, TYPE_CHECKING, Any
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from transitions.core import CallbacksArg, StateIdentifier, EventData

transitions/experimental/typing.pyi

@@ -1,7 +1,7 @@
-from typing import Any
+from typing import Union
 from transitions.core import MachineConfig
 from transitions.extensions.markup import MarkupConfig
 
 _placeholder_body: str
 
-def generate_base_model(config: MachineConfig | MarkupConfig) -> str: ...
+def generate_base_model(config: Union[MachineConfig, MarkupConfig]) -> str: ...

transitions/extensions/markup.pyi

@@ -21,7 +21,7 @@ class MarkupConfig(TypedDict):
     send_event: bool
     auto_transitions: bool
     ignore_invalid_triggers: bool
-    queued: bool | str
+    queued: Union[bool, str]
 
 
 class MarkupMachine(Machine):