conson-xp 1.41.0__tar.gz → 1.43.0__tar.gz

{conson_xp-1.41.0 → conson_xp-1.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.41.0
+Version: 1.43.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -49,6 +49,7 @@ Requires-Dist: twisted>=25.5.0
 Requires-Dist: bubus>=1.5.6
 Requires-Dist: psygnal>=0.15.0
 Requires-Dist: textual>=1.0.0
+Requires-Dist: python-statemachine>=2.5.0
 Description-Content-Type: text/markdown
 
 # 🔌 XP Protocol Communication Tool

{conson_xp-1.41.0 → conson_xp-1.43.0}/pyproject.toml

@@ -19,10 +19,11 @@ dependencies = [
     "bubus>=1.5.6",
     "psygnal>=0.15.0",
     "textual>=1.0.0",
+    "python-statemachine>=2.5.0",
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.41.0"
+version = "1.43.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.41.0 → conson_xp-1.43.0}/src/xp/__init__.py

@@ -3,7 +3,7 @@
 conson-xp package.
 """
 
-__version__ = "1.41.0"
+__version__ = "1.43.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-1.41.0 → conson_xp-1.43.0}/src/xp/cli/commands/conbus/conbus_actiontable_commands.py

@@ -61,7 +61,7 @@ def conbus_download_actiontable(ctx: Context, serial_number: str) -> None:
         """
         click.echo(progress, nl=False)
 
-    def on_finish(
+    def on_actiontable_received(
         _actiontable: ActionTable,
         actiontable_dict: Dict[str, Any],
         actiontable_short: list[str],
@@ -79,6 +79,9 @@ def conbus_download_actiontable(ctx: Context, serial_number: str) -> None:
             "actiontable": actiontable_dict,
         }
         click.echo(json.dumps(output, indent=2, default=str))
+
+    def on_finish() -> None:
+        """Handle successful completion of action table download."""
         service.stop_reactor()
 
     def on_error(error: str) -> None:
@@ -93,6 +96,7 @@ def conbus_download_actiontable(ctx: Context, serial_number: str) -> None:
     with service:
         service.on_progress.connect(on_progress)
         service.on_finish.connect(on_finish)
+        service.on_actiontable_received.connect(on_actiontable_received)
         service.on_error.connect(on_error)
         service.start(serial_number=serial_number)
         service.start_reactor()

conson_xp-1.43.0/src/xp/services/conbus/actiontable/actiontable_download_service.py

@@ -0,0 +1,467 @@
+"""Service for downloading ActionTable via Conbus protocol."""
+
+import logging
+from dataclasses import asdict
+from typing import Any, Dict, Optional
+
+from psygnal import SignalInstance
+from statemachine import State, StateMachine
+
+from xp.models.actiontable.actiontable import ActionTable
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.reply_telegram import ReplyTelegram
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.actiontable.actiontable_serializer import ActionTableSerializer
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class ActionTableDownloadService(StateMachine):
+    """TCP client service for downloading action tables from Conbus modules.
+
+    Inherits from StateMachine - the service IS the state machine.
+
+    Manages TCP socket connections, handles telegram generation and transmission,
+    and processes server responses for action table downloads.
+
+    Attributes:
+        on_progress: Signal emitted with telegram frame when progress is made.
+        on_error: Signal emitted with error message string when an error occurs.
+        on_finish: Signal emitted with (ActionTable, Dict[str, Any], list[str]) when complete.
+        idle: Initial state, waiting for connection.
+        receiving: Listening for telegrams, filtering relevant responses.
+        resetting: Timeout occurred, preparing error status query.
+        waiting_ok: Sent error status query, awaiting ACK/NAK.
+        requesting: Ready to send download request.
+        waiting_data: Awaiting actiontable chunk or EOF.
+        receiving_chunk: Processing received actiontable data.
+        processing_eof: Received EOF, deserializing actiontable.
+        completed: Download finished successfully.
+        do_connect: Transition from idle to receiving.
+        do_timeout: Transition from receiving to resetting.
+        send_error_status: Transition from resetting to waiting_ok.
+        error_status_received: Transition from waiting_ok to receiving (retry).
+        no_error_status_received: Transition from waiting_ok to requesting or completed.
+        send_download: Transition from requesting to waiting_data.
+        receive_chunk: Transition from waiting_data to receiving_chunk.
+        send_ack: Transition from receiving_chunk to waiting_data.
+        receive_eof: Transition from waiting_data to processing_eof.
+        do_finish: Transition from processing_eof to receiving.
+        receiving2: Second receiving state after EOF processing.
+        resetting2: Second resetting state for finalization phase.
+        waiting_ok2: Second waiting_ok state for finalization phase.
+        filter_telegram: Self-transition for filtering telegrams in receiving state.
+        filter_telegram2: Self-transition for filtering telegrams in receiving2 state.
+        do_timeout2: Timeout transition for finalization phase.
+        send_error_status2: Error status query transition for finalization phase.
+        error_status_received2: Error received transition for finalization phase.
+        no_error_status_received2: No error received transition to completed state.
+    """
+
+    # States (9 states as per spec)
+    idle = State(initial=True)
+    receiving = State()
+    resetting = State()
+    waiting_ok = State()
+
+    requesting = State()
+    waiting_data = State()
+    receiving_chunk = State()
+    processing_eof = State()
+
+    receiving2 = State()
+    resetting2 = State()
+    waiting_ok2 = State()
+
+    completed = State(final=True)
+
+    # Phase 1: Connection & Initialization
+    do_connect = idle.to(receiving)
+    filter_telegram = receiving.to(receiving)  # Self-transition for filtering
+    do_timeout = receiving.to(resetting) | waiting_ok.to(receiving)
+    send_error_status = resetting.to(waiting_ok)
+    error_status_received = waiting_ok.to(receiving)
+    no_error_status_received = waiting_ok.to(requesting)
+
+    # Phase 2: Download
+    send_download = requesting.to(waiting_data)
+    receive_chunk = waiting_data.to(receiving_chunk)
+    send_ack = receiving_chunk.to(waiting_data)
+    receive_eof = waiting_data.to(processing_eof)
+
+    # Phase 3: Finalization
+    do_finish = processing_eof.to(receiving2)
+    filter_telegram2 = receiving2.to(receiving2)  # Self-transition for filtering
+    do_timeout2 = receiving2.to(resetting2) | waiting_ok2.to(receiving2)
+    send_error_status2 = resetting2.to(waiting_ok2)
+    error_status_received2 = waiting_ok2.to(receiving2)
+    no_error_status_received2 = waiting_ok2.to(completed)
+
+    def __init__(
+        self,
+        conbus_protocol: ConbusEventProtocol,
+        actiontable_serializer: ActionTableSerializer,
+        telegram_service: TelegramService,
+    ) -> None:
+        """Initialize the action table download service.
+
+        Args:
+            conbus_protocol: ConbusEventProtocol instance.
+            actiontable_serializer: Action table serializer.
+            telegram_service: Telegram service for parsing.
+        """
+        self.conbus_protocol = conbus_protocol
+        self.serializer = actiontable_serializer
+        self.telegram_service = telegram_service
+        self.serial_number: str = ""
+        self.actiontable_data: list[str] = []
+        self.logger = logging.getLogger(__name__)
+
+        # Signals (instance attributes to avoid conflict with statemachine)
+        self.on_progress: SignalInstance = SignalInstance((str,))
+        self.on_error: SignalInstance = SignalInstance((str,))
+        self.on_finish: SignalInstance = SignalInstance()
+        self.on_actiontable_received: SignalInstance = SignalInstance(
+            (ActionTable, Dict[str, Any], list[str])
+        )
+
+        # Connect protocol signals
+        self.conbus_protocol.on_connection_made.connect(self._on_connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self._on_telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self._on_telegram_received)
+        self.conbus_protocol.on_timeout.connect(self._on_timeout)
+        self.conbus_protocol.on_failed.connect(self._on_failed)
+
+        # Initialize state machine
+        super().__init__(allow_event_without_transition=True)
+
+    # State machine lifecycle hooks
+
+    def on_enter_receiving(self) -> None:
+        """Enter receiving state - listening for telegrams."""
+        self.logger.debug("Entering RECEIVING state - waiting for telegrams")
+        self.conbus_protocol.wait()
+
+    def on_enter_receiving2(self) -> None:
+        """Enter receiving state - listening for telegrams."""
+        self.logger.debug("Entering RECEIVING2 state - waiting for telegrams")
+        self.conbus_protocol.wait()
+
+    def on_enter_resetting(self) -> None:
+        """Enter resetting state - query error status."""
+        self.logger.debug("Entering RESETTING state - querying error status")
+
+        # query_datapoint_module_error_code
+        self.conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=DataPointType.MODULE_ERROR_CODE.value,
+        )
+        self.send_error_status()
+
+    def on_enter_resetting2(self) -> None:
+        """Enter resetting state - query error status."""
+        self.logger.debug("Entering RESETTING2 state - querying error status")
+
+        # query_datapoint_module_error_code
+        self.conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=DataPointType.MODULE_ERROR_CODE.value,
+        )
+        self.send_error_status2()
+
+    def on_enter_waiting_ok(self) -> None:
+        """Enter waiting_ok state - awaiting ERROR/NO_ERROR."""
+        self.logger.debug("Entering WAITING_OK state - awaiting ERROR/NO_ERROR")
+        self.conbus_protocol.wait()
+
+    def on_enter_waiting_ok2(self) -> None:
+        """Enter waiting_ok state - awaiting ERROR/NO_ERROR."""
+        self.logger.debug("Entering WAITING_OK state - awaiting ERROR/NO_ERROR")
+        self.conbus_protocol.wait()
+
+    def on_enter_requesting(self) -> None:
+        """Enter requesting state - send download request."""
+        self.logger.debug("Entering REQUESTING state - sending download request")
+        self.conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.DOWNLOAD_ACTIONTABLE,
+            data_value="00",
+        )
+        self.send_download()
+
+    def on_enter_waiting_data(self) -> None:
+        """Enter waiting_data state - wait for actiontable chunks."""
+        self.logger.debug("Entering WAITING_DATA state - awaiting chunks")
+        self.conbus_protocol.wait()
+
+    def on_enter_receiving_chunk(self) -> None:
+        """Enter receiving_chunk state - send ACK."""
+        self.logger.debug("Entering RECEIVING_CHUNK state - sending ACK")
+        self.conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.ACK,
+            data_value="00",
+        )
+        self.send_ack()
+
+    def on_enter_processing_eof(self) -> None:
+        """Enter processing_eof state - deserialize and emit result."""
+        self.logger.debug("Entering PROCESSING_EOF state - deserializing")
+        all_data = "".join(self.actiontable_data)
+        actiontable = self.serializer.from_encoded_string(all_data)
+        actiontable_dict = asdict(actiontable)
+        actiontable_short = self.serializer.format_decoded_output(actiontable)
+        self.on_actiontable_received.emit(
+            actiontable, actiontable_dict, actiontable_short
+        )
+        self.do_finish()
+
+    def on_enter_completed(self) -> None:
+        """Enter completed state - download finished."""
+        self.logger.debug("Entering COMPLETED state - download finished")
+        self.on_finish.emit()
+
+    # Protocol event handlers
+
+    def _on_connection_made(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug("Connection made")
+        if self.idle.is_active:
+            self.do_connect()
+
+    def _on_telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
+        self.logger.debug(f"Telegram sent: {telegram_sent}")
+
+    def _on_read_datapoint_received(self, reply_telegram: ReplyTelegram) -> None:
+        """Handle READ_DATAPOINT response for error status check.
+
+        Args:
+            reply_telegram: The parsed reply telegram.
+        """
+        self.logger.debug(f"Received READ_DATAPOINT in {self.current_state}")
+
+        if reply_telegram.datapoint_type != DataPointType.MODULE_ERROR_CODE:
+            self.logger.debug(
+                f"Filtered: not a MODULE_ERROR_CODE (got {reply_telegram.datapoint_type})"
+            )
+            return
+
+        if reply_telegram.data_value == "00":
+            if self.waiting_ok.is_active:
+                self.no_error_status_received()
+
+        if reply_telegram.data_value != "00":
+            if self.waiting_ok.is_active:
+                self.error_status_received()
+
+        if reply_telegram.data_value == "00":
+            if self.waiting_ok2.is_active:
+                self.no_error_status_received2()
+
+        if reply_telegram.data_value != "00":
+            if self.waiting_ok2.is_active:
+                self.error_status_received2()
+
+    def _on_ack_received(self, _reply_telegram: ReplyTelegram) -> None:
+        """Handle ACK telegram received.
+
+        Args:
+            _reply_telegram: The parsed reply telegram (unused).
+        """
+        self.logger.debug(f"Received ACK in {self.current_state}")
+        if self.waiting_ok.is_active:
+            self.ack_received()
+
+        if self.waiting_ok2.is_active:
+            self.ack_received2()
+
+    def _on_nack_received(self, _reply_telegram: ReplyTelegram) -> None:
+        """Handle NAK telegram received.
+
+        Args:
+            _reply_telegram: The parsed reply telegram (unused).
+        """
+        self.logger.debug(f"Received NAK in {self.current_state}")
+        if self.waiting_ok.is_active:
+            self.nak_received()
+
+    def _on_actiontable_chunk_received(self, reply_telegram: ReplyTelegram) -> None:
+        """Handle actiontable chunk telegram received.
+
+        Args:
+            reply_telegram: The parsed reply telegram containing chunk data.
+        """
+        self.logger.debug(f"Received actiontable chunk in {self.current_state}")
+        if self.waiting_data.is_active:
+            data_part = reply_telegram.data_value[2:]
+            self.actiontable_data.append(data_part)
+            self.on_progress.emit(".")
+            self.receive_chunk()
+
+    def _on_eof_received(self, _reply_telegram: ReplyTelegram) -> None:
+        """Handle EOF telegram received.
+
+        Args:
+            _reply_telegram: The parsed reply telegram (unused).
+        """
+        self.logger.debug(f"Received EOF in {self.current_state}")
+        if self.waiting_data.is_active:
+            self.receive_eof()
+
+    def _on_telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
+
+        Args:
+            telegram_received: The telegram received event.
+        """
+        self.logger.debug(f"Received{telegram_received} in {self.current_state}")
+        if self.receiving.is_active:
+            self.filter_telegram()
+            return
+
+        # Filter invalid telegrams
+        if not telegram_received.checksum_valid:
+            self.logger.debug("Filtered: invalid checksum")
+            return
+        if telegram_received.telegram_type != TelegramType.REPLY.value:
+            self.logger.debug(
+                f"Filtered: not a reply (got {telegram_received.telegram_type})"
+            )
+            return
+        if telegram_received.serial_number != self.serial_number:
+            self.logger.debug(
+                f"Filtered: wrong serial {telegram_received.serial_number} != {self.serial_number}"
+            )
+            return
+
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+
+        if reply_telegram.system_function == SystemFunction.READ_DATAPOINT:
+            self._on_read_datapoint_received(reply_telegram)
+            return
+
+        if reply_telegram.system_function == SystemFunction.ACK:
+            self._on_ack_received(reply_telegram)
+            return
+
+        if reply_telegram.system_function == SystemFunction.NAK:
+            self._on_nack_received(reply_telegram)
+            return
+
+        if reply_telegram.system_function == SystemFunction.ACTIONTABLE:
+            self._on_actiontable_chunk_received(reply_telegram)
+            return
+
+        if reply_telegram.system_function == SystemFunction.EOF:
+            self._on_eof_received(reply_telegram)
+            return
+
+    def _on_timeout(self) -> None:
+        """Handle timeout event."""
+        self.logger.debug("Timeout occurred")
+        if self.receiving.is_active:
+            self.do_timeout()  # receiving -> resetting
+        elif self.waiting_ok.is_active:
+            self.do_timeout()  # waiting_ok -> receiving
+        elif self.receiving2.is_active:
+            self.do_timeout2()  # receiving2 -> resetting2
+        elif self.waiting_ok2.is_active:
+            self.do_timeout2()  # waiting_ok2 -> receiving2
+        else:
+            self.logger.debug("Timeout in non-recoverable state")
+            self.on_error.emit("Timeout")
+
+    def _on_failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
+        self.logger.debug(f"Failed: {message}")
+        self.on_error.emit(message)
+
+    # Public API
+
+    def start(
+        self,
+        serial_number: str,
+        timeout_seconds: Optional[float] = 2.0,
+    ) -> None:
+        """Run reactor in dedicated thread with its own event loop.
+
+        Args:
+            serial_number: Module serial number.
+            timeout_seconds: Optional timeout in seconds.
+        """
+        self.logger.info("Starting actiontable download")
+        self.serial_number = serial_number
+        if timeout_seconds:
+            self.conbus_protocol.timeout_seconds = timeout_seconds
+
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """Set operation timeout.
+
+        Args:
+            timeout_seconds: Timeout in seconds.
+        """
+        self.conbus_protocol.timeout_seconds = timeout_seconds
+
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.start_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop the reactor."""
+        self.conbus_protocol.stop_reactor()
+
+    def __enter__(self) -> "ActionTableDownloadService":
+        """Enter context manager - reset state for singleton reuse.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for singleton reuse
+        self.actiontable_data = []
+        self._download_complete = False
+        # Reset state machine to idle
+        self._reset_state()
+        return self
+
+    def _reset_state(self) -> None:
+        """Reset state machine to initial state."""
+        # python-statemachine uses model.state to track current state
+        # Set it directly to the initial state id
+        self.model.state = self.idle.id
+        self._download_complete = False
+
+    def __exit__(
+        self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
+    ) -> None:
+        """Exit context manager and disconnect signals."""
+        # Disconnect protocol signals
+        self.conbus_protocol.on_connection_made.disconnect(self._on_connection_made)
+        self.conbus_protocol.on_telegram_sent.disconnect(self._on_telegram_sent)
+        self.conbus_protocol.on_telegram_received.disconnect(self._on_telegram_received)
+        self.conbus_protocol.on_timeout.disconnect(self._on_timeout)
+        self.conbus_protocol.on_failed.disconnect(self._on_failed)
+        # Disconnect service signals
+        self.on_progress.disconnect()
+        self.on_error.disconnect()
+        self.on_finish.disconnect()
+        # Stop reactor
+        self.stop_reactor()

{conson_xp-1.41.0 → conson_xp-1.43.0}/src/xp/services/protocol/conbus_event_protocol.py

@@ -103,6 +103,16 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         # Start inactivity timeout
         self._reset_timeout()
 
+    def wait(self, wait_timeout: Optional[float] = None) -> None:
+        """Wait for incoming telegrams with optional timeout override.
+
+        Args:
+            wait_timeout: Optional timeout in seconds to override default.
+        """
+        if wait_timeout:
+            self.timeout_seconds = wait_timeout
+        self._reset_timeout()
+
     def dataReceived(self, data: bytes) -> None:
         """Handle received data from TCP connection.
 

{conson_xp-1.41.0 → conson_xp-1.43.0}/src/xp/services/server/server_service.py

@@ -337,7 +337,7 @@ class ServerService:
                 self.logger.warning(f"Failed to parse telegram: {telegram}")
                 return responses
 
-            self.client_buffers.broadcast(parsed_telegram.raw_telegram)
+            # self.client_buffers.broadcast(parsed_telegram.raw_telegram)
 
             # Handle discover requests
             if self.discover_service.is_discover_request(parsed_telegram):

{conson_xp-1.41.0 → conson_xp-1.43.0}/tests/integration/test_actiontable_integration.py

@@ -103,7 +103,11 @@ class TestActionTableIntegration:
         mock_service.__exit__ = Mock(return_value=None)
 
         # Store the callbacks that are connected
-        callbacks = {"on_finish": None, "on_progress": None}
+        callbacks = {
+            "on_finish": None,
+            "on_progress": None,
+            "on_actiontable_received": None,
+        }
 
         def mock_on_finish_connect(callback):
             """Mock on_finish event connection.
@@ -121,10 +125,21 @@ class TestActionTableIntegration:
             """
             callbacks["on_progress"] = callback
 
+        def mock_on_actiontable_received_connect(callback):
+            """Mock on_actiontable_received event connection.
+
+            Args:
+                callback: Callback function to store.
+            """
+            callbacks["on_actiontable_received"] = callback
+
         mock_service.on_finish.connect.side_effect = mock_on_finish_connect
         mock_service.on_progress.connect.side_effect = mock_on_progress_connect
+        mock_service.on_actiontable_received.connect.side_effect = (
+            mock_on_actiontable_received_connect
+        )
 
-        # Mock the start method to call finish_callback immediately
+        # Mock the start method to call callbacks immediately
         def mock_start(serial_number):
             """Test helper function.
 
@@ -136,11 +151,14 @@ class TestActionTableIntegration:
             actiontable_short = ActionTableSerializer.format_decoded_output(
                 sample_actiontable
             )
-            # Call the on_finish callback that was connected
-            if callbacks["on_finish"]:
-                callbacks["on_finish"](
+            # Call the on_actiontable_received callback with data
+            if callbacks["on_actiontable_received"]:
+                callbacks["on_actiontable_received"](
                     sample_actiontable, actiontable_dict, actiontable_short
                 )
+            # Call the on_finish callback without arguments
+            if callbacks["on_finish"]:
+                callbacks["on_finish"]()
 
         def mock_start_reactor() -> None:
             """Mock reactor start method."""

{conson_xp-1.41.0 → conson_xp-1.43.0}/tests/unit/test_cli/test_conbus_actiontable_commands.py

@@ -60,11 +60,13 @@ class TestConbusActionTableCommands:
         # Create mock signals
         mock_service.on_progress = Mock()
         mock_service.on_finish = Mock()
+        mock_service.on_actiontable_received = Mock()
         mock_service.on_error = Mock()
 
         # Track connected callbacks
         progress_callbacks = []
         finish_callbacks = []
+        actiontable_received_callbacks = []
         error_callbacks = []
 
         def connect_progress(callback):
@@ -83,6 +85,14 @@ class TestConbusActionTableCommands:
             """
             finish_callbacks.append(callback)
 
+        def connect_actiontable_received(callback):
+            """Mock connect for actiontable_received signal.
+
+            Args:
+                callback: Callback function to connect.
+            """
+            actiontable_received_callbacks.append(callback)
+
         def connect_error(callback):
             """Mock connect for error signal.
 
@@ -93,6 +103,7 @@ class TestConbusActionTableCommands:
 
         mock_service.on_progress.connect = connect_progress
         mock_service.on_finish.connect = connect_finish
+        mock_service.on_actiontable_received.connect = connect_actiontable_received
         mock_service.on_error.connect = connect_error
 
         def mock_start_reactor():
@@ -107,8 +118,12 @@ class TestConbusActionTableCommands:
                     actiontable_short = ActionTableSerializer.format_decoded_output(
                         actiontable
                     )
-                    for callback in finish_callbacks:
+                    # Emit on_actiontable_received with data
+                    for callback in actiontable_received_callbacks:
                         callback(actiontable, actiontable_dict, actiontable_short)
+                    # Emit on_finish without arguments
+                    for callback in finish_callbacks:
+                        callback()
 
         mock_service.start = Mock()
         mock_service.start_reactor.side_effect = mock_start_reactor