MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/pea/user_logic/user_logic_service_test.py

@@ -0,0 +1,289 @@
+"""
+Unit tests for the UserLogicService class.
+"""
+
+import unittest
+from unittest.mock import Mock, call, patch
+from mtppy.pea.user_logic.user_logic_service import UserLogicService
+from mtppy.pea.user_logic.user_logic_registry import UserLogicRegistry
+from mtppy.part4.definitions.state_codes import StateCodes
+
+
+class TestUserLogicService(unittest.TestCase):
+    """Test cases for the UserLogicService class."""
+
+    def setUp(self):
+        """Set up test fixtures before each test method."""
+        self.service = UserLogicService(
+            tag_name="test_service", tag_description="Test service description"
+        )
+        self.registry = UserLogicRegistry()
+
+    def test_init(self):
+        """Test that the UserLogicService initializes correctly."""
+        self.assertEqual(self.service.name, "test_service")
+        self.assertEqual(self.service.tag_description, "Test service description")
+        self.assertIsNone(self.service._registry)
+        self.assertEqual(self.service._cycle_time, 0.5)
+
+    def test_init_with_registry(self):
+        """Test that the UserLogicService initializes with a registry."""
+        service = UserLogicService(
+            tag_name="test_service",
+            tag_description="Test service description",
+            registry=self.registry,
+        )
+        self.assertEqual(service._registry, self.registry)
+
+    def test_set_registry(self):
+        """Test setting the user logic registry."""
+        self.service.set_registry(self.registry)
+        self.assertEqual(self.service._registry, self.registry)
+
+    def test_dispatch_with_registry(self):
+        """Test dispatch method with a registry."""
+
+        def mock_func(service):
+            return True
+
+        self.registry.register("test_func")(mock_func)
+        self.service.set_registry(self.registry)
+
+        # Mock the service methods that would normally be called
+        with patch.object(
+            self.service, "_lookup_procedure_cur_name", return_value="proc1"
+        ):
+            with patch.object(
+                self.service, "_user_code_callback_name"
+            ) as mock_callback_name:
+                mock_callback_name.return_value = "test_func"
+
+                # Mock dispatch to avoid actual execution
+                with patch.object(self.registry, "dispatch", return_value=True):
+                    result = self.service.dispatch("test_func")
+                    self.assertTrue(result)
+
+    def test_dispatch_without_registry(self):
+        """Test dispatch method without a registry raises RuntimeError."""
+        with self.assertRaises(RuntimeError):
+            self.service.dispatch("test_func")
+
+    def test_get_param(self):
+        """Test get_param method."""
+        # Create a mock procedure with parameters
+        mock_proc = Mock()
+        mock_proc.procedure_parameters = {"param1": "value1"}
+        mock_proc.process_value_ins = {}
+        mock_proc.process_value_outs = {}
+        mock_proc.report_values = {}
+        mock_proc.required_equipment = {}
+
+        # Mock the get_current_procedure method
+        with patch.object(
+            self.service, "get_current_procedure", return_value=mock_proc
+        ):
+            result = self.service.get_param("param1")
+            self.assertEqual(result, "value1")
+
+    def test_get_param_not_found(self):
+        """Test get_param method when parameter is not found."""
+        # Create a mock procedure with no parameters
+        mock_proc = Mock()
+        mock_proc.procedure_parameters = {}
+        mock_proc.process_value_ins = {}
+        mock_proc.process_value_outs = {}
+        mock_proc.report_values = {}
+        mock_proc.required_equipment = {}
+
+        # Mock the get_current_procedure method
+        with patch.object(
+            self.service, "get_current_procedure", return_value=mock_proc
+        ):
+            result = self.service.get_param("nonexistent")
+            self.assertIsNone(result)
+
+    def test_user_code_callback_name(self):
+        """Test _user_code_callback_name method."""
+        callback_name = self.service._user_code_callback_name(
+            "proc1", StateCodes.IDLE.string, UserLogicService.ENTRY
+        )
+        self.assertEqual(
+            callback_name,
+            f"test_service.proc1.{StateCodes.IDLE.string}.{UserLogicService.ENTRY}",
+        )
+
+    def test_transient_state(self):
+        """Test _transient_state method."""
+        # Mock the helper methods
+        with patch.object(
+            self.service, "_lookup_procedure_cur_name", return_value="proc1"
+        ):
+            with patch.object(self.service, "dispatch") as mock_dispatch:
+                with patch.object(self.service, "state_change"):
+                    with patch("mtppy.pea.user_logic.user_logic_service.logger"):
+                        self.service._transient_state(StateCodes.IDLE.string)
+
+                        # Verify that dispatch was called for entry, do, and exit
+                        self.assertEqual(mock_dispatch.call_count, 3)
+
+    def test_transient_state_dispatches_entry_do_and_exit_in_order(self):
+        """Test that a transient state dispatches entry, do, and exit callbacks."""
+        with patch.object(
+            self.service, "_lookup_procedure_cur_name", return_value="proc1"
+        ):
+            with patch.object(self.service, "dispatch") as mock_dispatch:
+                with patch.object(self.service, "state_change"):
+                    with patch("mtppy.pea.user_logic.user_logic_service.logger"):
+                        self.service._transient_state(StateCodes.IDLE.string)
+
+        self.assertEqual(
+            mock_dispatch.call_args_list,
+            [
+                call(
+                    self.service._user_code_callback_name(
+                        "proc1", StateCodes.IDLE.string, UserLogicService.ENTRY
+                    )
+                ),
+                call(
+                    self.service._user_code_callback_name(
+                        "proc1", StateCodes.IDLE.string, UserLogicService.DO
+                    )
+                ),
+                call(
+                    self.service._user_code_callback_name(
+                        "proc1", StateCodes.IDLE.string, UserLogicService.EXIT
+                    )
+                ),
+            ],
+        )
+
+    def test_cyclic_state(self):
+        """Test _cyclic_state method."""
+        # Mock the helper methods
+        with patch.object(
+            self.service, "_lookup_procedure_cur_name", return_value="proc1"
+        ):
+            with patch.object(self.service, "dispatch") as mock_dispatch:
+                with patch.object(self.service, "is_state", side_effect=[True, False]):
+                    with patch.object(self.service, "thread_ctrl") as mock_thread_ctrl:
+                        mock_thread_ctrl.is_stopped.return_value = False
+                        with patch(
+                            "mtppy.pea.user_logic.user_logic_service.time.sleep"
+                        ):
+                            with patch(
+                                "mtppy.pea.user_logic.user_logic_service.logger"
+                            ):
+                                self.service._cyclic_state(StateCodes.IDLE.string)
+
+                                # Verify that dispatch was called for entry and do at least once
+                                self.assertGreaterEqual(mock_dispatch.call_count, 2)
+
+
+class TestUserLogicServiceStateMethods(unittest.TestCase):
+    """Test state methods of UserLogicService."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.service = UserLogicService(
+            tag_name="test_service", tag_description="Test service description"
+        )
+
+    def test_idle_method(self):
+        """Test idle method calls _cyclic_state."""
+        with patch.object(self.service, "_cyclic_state") as mock_cyclic_state:
+            self.service.idle()
+            mock_cyclic_state.assert_called_once_with(StateCodes.IDLE.string)
+
+    def test_starting_method(self):
+        """Test starting method calls _transient_state."""
+        with patch.object(self.service, "_transient_state") as mock_transient_state:
+            self.service.starting()
+            mock_transient_state.assert_called_once_with(StateCodes.STARTING.string)
+
+    def test_execute_method(self):
+        """Test execute method calls _cyclic_state."""
+        with patch.object(self.service, "_cyclic_state") as mock_cyclic_state:
+            self.service.execute()
+            mock_cyclic_state.assert_called_once_with(StateCodes.EXECUTE.string)
+
+    def test_completing_method(self):
+        """Test completing method calls _transient_state."""
+        with patch.object(self.service, "_transient_state") as mock_transient_state:
+            self.service.completing()
+            mock_transient_state.assert_called_once_with(StateCodes.COMPLETING.string)
+
+    def test_completed_method(self):
+        """Test completed method calls _cyclic_state."""
+        with patch.object(self.service, "_cyclic_state") as mock_cyclic_state:
+            self.service.completed()
+            mock_cyclic_state.assert_called_once_with(StateCodes.COMPLETING.string)
+
+    def test_pausing_method(self):
+        """Test pausing method calls _transient_state."""
+        with patch.object(self.service, "_transient_state") as mock_transient_state:
+            self.service.pausing()
+            mock_transient_state.assert_called_once_with(StateCodes.PAUSING.string)
+
+    def test_paused_method(self):
+        """Test paused method calls _cyclic_state."""
+        with patch.object(self.service, "_cyclic_state") as mock_cyclic_state:
+            self.service.paused()
+            mock_cyclic_state.assert_called_once_with(StateCodes.PAUSED.string)
+
+    def test_resuming_method(self):
+        """Test resuming method calls _transient_state."""
+        with patch.object(self.service, "_transient_state") as mock_transient_state:
+            self.service.resuming()
+            mock_transient_state.assert_called_once_with(StateCodes.RESUMING.string)
+
+    def test_holding_method(self):
+        """Test holding method calls _transient_state."""
+        with patch.object(self.service, "_transient_state") as mock_transient_state:
+            self.service.holding()
+            mock_transient_state.assert_called_once_with(StateCodes.HOLDING.string)
+
+    def test_held_method(self):
+        """Test held method calls _cyclic_state."""
+        with patch.object(self.service, "_cyclic_state") as mock_cyclic_state:
+            self.service.held()
+            mock_cyclic_state.assert_called_once_with(StateCodes.HELD.string)
+
+    def test_unholding_method(self):
+        """Test unholding method calls _transient_state."""
+        with patch.object(self.service, "_transient_state") as mock_transient_state:
+            self.service.unholding()
+            mock_transient_state.assert_called_once_with(StateCodes.UNHOLDING.string)
+
+    def test_stopping_method(self):
+        """Test stopping method calls _transient_state."""
+        with patch.object(self.service, "_transient_state") as mock_transient_state:
+            self.service.stopping()
+            mock_transient_state.assert_called_once_with(StateCodes.STOPPING.string)
+
+    def test_stopped_method(self):
+        """Test stopped method calls _cyclic_state."""
+        with patch.object(self.service, "_cyclic_state") as mock_cyclic_state:
+            self.service.stopped()
+            mock_cyclic_state.assert_called_once_with(StateCodes.STOPPED.string)
+
+    def test_aborting_method(self):
+        """Test aborting method calls _transient_state."""
+        with patch.object(self.service, "_transient_state") as mock_transient_state:
+            self.service.aborting()
+            mock_transient_state.assert_called_once_with(StateCodes.ABORTING.string)
+
+    def test_aborted_method(self):
+        """Test aborted method calls _cyclic_state."""
+        with patch.object(self.service, "_cyclic_state") as mock_cyclic_state:
+            self.service.aborted()
+            mock_cyclic_state.assert_called_once_with(StateCodes.ABORTED.string)
+
+    def test_resetting_method(self):
+        """Test resetting method calls _transient_state."""
+        with patch.object(self.service, "_transient_state") as mock_transient_state:
+            self.service.resetting()
+            mock_transient_state.assert_called_once_with(StateCodes.RESETTING.string)
+
+
+if __name__ == "__main__":
+    unittest.main()

mtppy/utils/__init__.py

@@ -0,0 +1,4 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"

mtppy/utils/data_assembly_dict.py

@@ -0,0 +1,61 @@
+"""helper for adding typed items to a dict from different sources."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from collections.abc import Mapping, Sequence
+from typing import Any, Protocol, get_type_hints
+
+
+class TagNamed(Protocol):
+    @property
+    def tag_name(self) -> str: ...  # type-only declaration (... instead of pass)
+
+
+type ElementSource[T: TagNamed] = (
+    T | Sequence[ElementSource[T]] | Mapping[Any, ElementSource[T]] | None
+)
+
+
+class DataAssemblyDict[T: TagNamed](dict[str, T]):
+    """Dictionary that collects elements by their ``tag_name`` attribute."""
+
+    def __init__(
+        self,
+        element_type: type[T],
+        element_name: str | None = None,
+        element: ElementSource[T] = None,
+    ) -> None:
+        if not self._has_tag_name(element_type):
+            raise TypeError(f"{element_type.__name__} must have a tag_name attribute")
+        super().__init__()
+        self.element_type = element_type
+        self.element_name = element_name or element_type.__name__
+        self.add(element)
+
+    @staticmethod
+    def _has_tag_name(element_type: type[T]) -> bool:
+        return hasattr(element_type, "tag_name") or "tag_name" in get_type_hints(
+            element_type,
+        )
+
+    def add(self, element: ElementSource[T]) -> None:
+        """Add an element or nested collection of elements."""
+        if element is None:
+            return
+        if isinstance(element, self.element_type):
+            self[element.tag_name] = element
+        elif isinstance(element, Sequence) and not isinstance(
+            element,
+            (str, bytes, bytearray),
+        ):
+            for nested_element in element:
+                self.add(nested_element)
+        elif isinstance(element, Mapping):
+            for nested_element in element.values():
+                self.add(nested_element)
+        else:
+            msg = f"{getattr(element, 'tag_name', repr(element))} is not a {self.element_name}"
+            raise TypeError(msg)

mtppy/utils/data_assembly_dict_test.py

@@ -0,0 +1,107 @@
+"""Tests for data assembly dictionary helpers."""
+
+from dataclasses import dataclass
+
+import pytest
+
+from mtppy.utils.data_assembly_dict import DataAssemblyDict
+
+
+@dataclass
+class Element:
+    tag_name: str
+
+
+class OtherElement:
+    def __init__(self, tag_name: str) -> None:
+        self.tag_name = tag_name
+
+
+def test_data_assembly_dict_stores_element_type_once() -> None:
+    elements = DataAssemblyDict(Element)
+    first = Element("Element1")
+    second = Element("Element2")
+
+    elements.add([first, {"second": second}])
+
+    assert elements == {"Element1": first, "Element2": second}
+
+
+def test_data_assembly_dict_requires_tag_name_on_element_class() -> None:
+    with pytest.raises(TypeError, match="OtherElement must have a tag_name attribute"):
+        DataAssemblyDict(OtherElement)
+
+
+def test_data_assembly_dict_adds_element_by_tag_name() -> None:
+    target = DataAssemblyDict(Element)
+    element = Element("Element1")
+
+    target.add(element)
+
+    assert target == {"Element1": element}
+
+
+def test_data_assembly_dict_ignores_none() -> None:
+    target = DataAssemblyDict(Element)
+
+    target.add(None)
+
+    assert target == {}
+
+
+def test_data_assembly_dict_recursively_adds_elements_from_a_list() -> None:
+    target = DataAssemblyDict(Element)
+    elements = [Element("Element1"), Element("Element2")]
+
+    target.add(elements)
+
+    assert target == {element.tag_name: element for element in elements}
+
+
+def test_data_assembly_dict_recursively_adds_elements_from_a_dictionary() -> None:
+    target = DataAssemblyDict(Element)
+    elements = {"first": Element("Element1"), "second": Element("Element2")}
+
+    target.add(elements)
+
+    assert target == {element.tag_name: element for element in elements.values()}
+
+
+def test_data_assembly_dict_recurses_through_nested_lists_and_dictionaries() -> None:
+    target = DataAssemblyDict(Element)
+    first = Element("Element1")
+    second = Element("Element2")
+    nested_elements: list[object] = [first, {"second": second}, None]
+
+    target.add(nested_elements)  # type: ignore[arg-type]
+
+    assert target == {"Element1": first, "Element2": second}
+
+
+def test_data_assembly_dict_overwrites_existing_tag_name() -> None:
+    target = DataAssemblyDict(Element)
+    target.add(Element("Element1"))
+    element = Element("Element1")
+
+    target.add(element)
+
+    assert target == {"Element1": element}
+
+
+@pytest.mark.parametrize("invalid_element", ["invalid", 1, OtherElement("Other")])
+def test_data_assembly_dict_rejects_invalid_elements(invalid_element: object) -> None:
+    target = DataAssemblyDict(Element)
+
+    with pytest.raises(TypeError, match="is not a Element"):
+        target.add(invalid_element)  # type: ignore[arg-type]
+
+    assert target == {}
+
+
+def test_data_assembly_dict_rejects_invalid_nested_elements() -> None:
+    target = DataAssemblyDict(Element)
+
+    with pytest.raises(TypeError, match="'invalid' is not a Element"):
+        target.add([Element("Element1"), "invalid"])  # type: ignore[arg-type]
+
+    assert target == {"Element1": target["Element1"]}