bec-ipython-client 3.70.0__py3-none-any.whl → 3.86.1__py3-none-any.whl

tests/client_tests/test_ipython_live_updates.py

@@ -7,34 +7,94 @@ from bec_lib import messages
 from bec_lib.queue_items import QueueItem
 
 
-@pytest.mark.timeout(20)
-def test_live_updates_process_queue_pending(bec_client_mock):
+@pytest.fixture
+def queue_elements(bec_client_mock):
     client = bec_client_mock
-    live_updates = IPythonLiveUpdates(client)
     request_msg = messages.ScanQueueMessage(
         scan_type="grid_scan",
         parameter={"args": {"samx": (-5, 5, 3)}, "kwargs": {}},
         queue="primary",
         metadata={"RID": "something"},
     )
+    request_block = messages.RequestBlock(
+        msg=request_msg,
+        RID="req_id",
+        scan_motors=["samx"],
+        report_instructions=[],
+        readout_priority={"monitored": ["samx"]},
+        is_scan=True,
+        scan_number=1,
+        scan_id="scan_id",
+    )
     queue = QueueItem(
         scan_manager=client.queue,
         queue_id="queue_id",
-        request_blocks=[request_msg],
+        request_blocks=[request_block],
         status="PENDING",
         active_request_block={},
         scan_id=["scan_id"],
     )
-    client.queue.queue_storage.current_scan_queue = {"primary": {"status": "RUNNING"}}
+    return queue, request_block, request_msg
+
+
+@pytest.fixture
+def sample_request_msg():
+    return messages.ScanQueueMessage(
+        scan_type="grid_scan",
+        parameter={"args": {"samx": (-5, 5, 3)}, "kwargs": {}},
+        queue="primary",
+        metadata={"RID": "something"},
+    )
+
+
+@pytest.fixture
+def sample_request_block(sample_request_msg):
+    return messages.RequestBlock(
+        msg=sample_request_msg,
+        RID="req_id",
+        scan_motors=["samx"],
+        report_instructions=[],
+        readout_priority={"monitored": ["samx"]},
+        is_scan=True,
+        scan_number=1,
+        scan_id="scan_id",
+    )
+
+
+@pytest.fixture
+def sample_queue_info_entry(sample_request_block):
+    return messages.QueueInfoEntry(
+        queue_id="test_queue_id",
+        scan_id=["scan_id"],
+        is_scan=[True],
+        request_blocks=[sample_request_block],
+        scan_number=[1],
+        status="RUNNING",
+        active_request_block=None,
+    )
+
+
+@pytest.fixture
+def sample_scan_queue_status(sample_queue_info_entry):
+    return messages.ScanQueueStatus(info=[sample_queue_info_entry], status="RUNNING")
+
+
+@pytest.mark.timeout(20)
+def test_live_updates_process_queue_pending(bec_client_mock, queue_elements):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+    queue, request_block, request_msg = queue_elements
+
+    client.queue.queue_storage.current_scan_queue = {
+        "primary": messages.ScanQueueStatus(info=[], status="RUNNING")
+    }
     with mock.patch.object(queue, "_update_with_buffer"):
         with mock.patch(
             "bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock
         ) as queue_pos:
             queue_pos.return_value = 2
             with mock.patch.object(
-                live_updates,
-                "_available_req_blocks",
-                return_value=[{"report_instructions": [], "content": {"scan_type": "grid_scan"}}],
+                live_updates, "_available_req_blocks", return_value=[request_block]
             ):
                 with mock.patch.object(live_updates, "_process_report_instructions") as process:
                     with mock.patch("builtins.print") as prt:
@@ -45,39 +105,30 @@ def test_live_updates_process_queue_pending(bec_client_mock):
 
 
 @pytest.mark.timeout(20)
-def test_live_updates_process_queue_running(bec_client_mock):
+def test_live_updates_process_queue_running(bec_client_mock, queue_elements):
     client = bec_client_mock
     live_updates = IPythonLiveUpdates(client)
-    request_msg = messages.ScanQueueMessage(
-        scan_type="grid_scan",
-        parameter={"args": {"samx": (-5, 5, 3)}, "kwargs": {}},
-        queue="primary",
-        metadata={"RID": "something"},
-    )
+    _, request_block, request_msg = queue_elements
     queue = QueueItem(
         scan_manager=client.queue,
         queue_id="queue_id",
-        request_blocks=[request_msg],
+        request_blocks=[request_block],
         status="RUNNING",
         active_request_block={},
         scan_id=["scan_id"],
     )
     live_updates._active_request = request_msg
-    client.queue.queue_storage.current_scan_queue = {"primary": {"status": "RUNNING"}}
+    request_block.report_instructions = [{"wait_table": 10}]
+    client.queue.queue_storage.current_scan_queue = {
+        "primary": messages.ScanQueueStatus(info=[], status="RUNNING")
+    }
     with mock.patch.object(queue, "_update_with_buffer"):
         with mock.patch(
             "bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock
         ) as queue_pos:
             queue_pos.return_value = 2
             with mock.patch.object(
-                live_updates,
-                "_available_req_blocks",
-                return_value=[
-                    {
-                        "report_instructions": [{"wait_table": 10}],
-                        "content": {"scan_type": "grid_scan"},
-                    }
-                ],
+                live_updates, "_available_req_blocks", return_value=[request_block]
             ):
                 with mock.patch.object(live_updates, "_process_instruction") as process:
                     with mock.patch("builtins.print") as prt:
@@ -88,37 +139,19 @@ def test_live_updates_process_queue_running(bec_client_mock):
 
 
 @pytest.mark.timeout(20)
-def test_live_updates_process_queue_without_status(bec_client_mock):
+def test_live_updates_process_queue_without_status(bec_client_mock, queue_elements):
     client = bec_client_mock
     live_updates = IPythonLiveUpdates(client)
-    request_msg = messages.ScanQueueMessage(
-        scan_type="grid_scan",
-        parameter={"args": {"samx": (-5, 5, 3)}, "kwargs": {}},
-        queue="primary",
-        metadata={"RID": "something"},
-    )
-    queue = QueueItem(
-        scan_manager=client.queue,
-        queue_id="queue_id",
-        request_blocks=[request_msg],
-        status=None,
-        active_request_block={},
-        scan_id=["scan_id"],
-    )
+    queue, _, request_msg = queue_elements
     with mock.patch.object(queue, "_update_with_buffer"):
         assert live_updates._process_queue(queue, request_msg, "req_id") is False
 
 
 @pytest.mark.timeout(20)
-def test_live_updates_process_queue_without_queue_number(bec_client_mock):
+def test_live_updates_process_queue_without_queue_number(bec_client_mock, queue_elements):
     client = bec_client_mock
     live_updates = IPythonLiveUpdates(client)
-    request_msg = messages.ScanQueueMessage(
-        scan_type="grid_scan",
-        parameter={"args": {"samx": (-5, 5, 3)}, "kwargs": {}},
-        queue="primary",
-        metadata={"RID": "something"},
-    )
+    queue, _, request_msg = queue_elements
 
     with mock.patch(
         "bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock
@@ -136,24 +169,182 @@ def test_live_updates_process_queue_without_queue_number(bec_client_mock):
             assert live_updates._process_queue(queue, request_msg, "req_id") is False
 
 
-# @pytest.mark.timeout(20)
-# @pytest.mark.asyncio
-# def test_live_updates_process_instruction_readback(bec_client_mock):
-#     client = bec_client_mock
-#     live_updates = IPythonLiveUpdates(client)
-#     request_msg = messages.ScanQueueMessage(
-#         scan_type="grid_scan",
-#         parameter={"args": {"samx": (-5, 5, 3)}, "kwargs": {}},
-#         queue="primary",
-#         metadata={"RID": "something"},
-#     )
-#     live_updates._active_request = request_msg
-#     live_updates._user_callback = []
-#     client.queue.queue_storage.current_scan_queue = {"primary": {"status": "RUNNING"}}
-#     with mock.patch(
-#         "bec_client_mock.callbacks.ipython_live_updates.LiveUpdatesTable", new_callable=mock.Co
-#     ) as table:
-#         live_updates._process_instruction({"scan_progress": 10})
-#         table.assert_called_once_with(
-#             client, report_instructions={"scan_progress": 10}, request=request_msg, callbacks=[]
-#         )
+@pytest.mark.timeout(20)
+def test_available_req_blocks(bec_client_mock, queue_elements):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+    queue, request_block, request_msg = queue_elements
+
+    # Test with matching RID
+    available_blocks = live_updates._available_req_blocks(queue, request_msg)
+    assert (
+        len(available_blocks) == 0
+    )  # request_block.RID is "req_id", request_msg.metadata["RID"] is "something"
+
+    # Test with correct RID
+    request_block.RID = "something"
+    available_blocks = live_updates._available_req_blocks(queue, request_msg)
+    assert len(available_blocks) == 1
+    assert available_blocks[0] == request_block
+
+
+@pytest.mark.timeout(20)
+def test_available_req_blocks_multiple_blocks(bec_client_mock):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    request_msg = messages.ScanQueueMessage(
+        scan_type="grid_scan",
+        parameter={"args": {"samx": (-5, 5, 3)}, "kwargs": {}},
+        queue="primary",
+        metadata={"RID": "test_rid"},
+    )
+
+    request_block1 = messages.RequestBlock(
+        msg=request_msg,
+        RID="test_rid",
+        scan_motors=["samx"],
+        report_instructions=[],
+        readout_priority={"monitored": ["samx"]},
+        is_scan=True,
+        scan_number=1,
+        scan_id="scan_id_1",
+    )
+
+    request_block2 = messages.RequestBlock(
+        msg=request_msg,
+        RID="test_rid",
+        scan_motors=["samy"],
+        report_instructions=[],
+        readout_priority={"monitored": ["samy"]},
+        is_scan=True,
+        scan_number=2,
+        scan_id="scan_id_2",
+    )
+
+    request_block3 = messages.RequestBlock(
+        msg=request_msg,
+        RID="different_rid",
+        scan_motors=["samz"],
+        report_instructions=[],
+        readout_priority={"monitored": ["samz"]},
+        is_scan=True,
+        scan_number=3,
+        scan_id="scan_id_3",
+    )
+
+    queue = QueueItem(
+        scan_manager=client.queue,
+        queue_id="queue_id",
+        request_blocks=[request_block1, request_block2, request_block3],
+        status="RUNNING",
+        active_request_block={},
+        scan_id=["scan_id_1", "scan_id_2", "scan_id_3"],
+    )
+
+    available_blocks = live_updates._available_req_blocks(queue, request_msg)
+    assert len(available_blocks) == 2
+    assert request_block1 in available_blocks
+    assert request_block2 in available_blocks
+    assert request_block3 not in available_blocks
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_no_queue(bec_client_mock):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when client.queue is None
+    client.queue = None
+    assert live_updates._element_in_queue() is False
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_no_current_scan_queue(bec_client_mock):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when current_scan_queue is None
+    client.queue.queue_storage.current_scan_queue = None
+    assert live_updates._element_in_queue() is False
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_no_primary_queue(bec_client_mock):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when primary queue doesn't exist
+    scan_queue_status = messages.ScanQueueStatus(info=[], status="RUNNING")
+    client.queue.queue_storage.current_scan_queue = {"secondary": scan_queue_status}
+    assert live_updates._element_in_queue() is False
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_no_queue_info(bec_client_mock):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when queue_info is empty
+    scan_queue_status = messages.ScanQueueStatus(info=[], status="RUNNING")
+    client.queue.queue_storage.current_scan_queue = {"primary": scan_queue_status}
+    assert live_updates._element_in_queue() is False
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_no_current_queue(bec_client_mock, sample_scan_queue_status):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when _current_queue is None
+    live_updates._current_queue = None
+    client.queue.queue_storage.current_scan_queue = {"primary": sample_scan_queue_status}
+    assert live_updates._element_in_queue() is False
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_queue_id_not_in_info(bec_client_mock, sample_request_block):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when queue_id is not in info
+    current_queue = mock.MagicMock()
+    current_queue.queue_id = "my_queue_id"
+    live_updates._current_queue = current_queue
+
+    queue_info_entry = messages.QueueInfoEntry(
+        queue_id="different_queue_id",
+        scan_id=["scan_id"],
+        is_scan=[True],
+        request_blocks=[sample_request_block],
+        scan_number=[1],
+        status="RUNNING",
+        active_request_block=None,
+    )
+    scan_queue_status = messages.ScanQueueStatus(info=[queue_info_entry], status="RUNNING")
+    client.queue.queue_storage.current_scan_queue = {"primary": scan_queue_status}
+    assert live_updates._element_in_queue() is False
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_queue_id_in_info(bec_client_mock, sample_request_block):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when queue_id is in info (should return True)
+    current_queue = mock.MagicMock()
+    current_queue.queue_id = "my_queue_id"
+    live_updates._current_queue = current_queue
+
+    queue_info_entry = messages.QueueInfoEntry(
+        queue_id="my_queue_id",
+        scan_id=["scan_id"],
+        is_scan=[True],
+        request_blocks=[sample_request_block],
+        scan_number=[1],
+        status="RUNNING",
+        active_request_block=None,
+    )
+    scan_queue_status = messages.ScanQueueStatus(info=[queue_info_entry], status="RUNNING")
+    client.queue.queue_storage.current_scan_queue = {"primary": scan_queue_status}
+    assert live_updates._element_in_queue() is True

tests/client_tests/test_live_table.py

@@ -107,7 +107,6 @@ class TestLiveTable:
     )
     def test_get_devices_from_scan_data(self, bec_client_mock, request_msg, scan_report_devices):
         client = bec_client_mock
-        client.start()
         data = messages.ScanMessage(
             point_id=0, scan_id="", data={}, metadata={"scan_report_devices": scan_report_devices}
         )

tests/client_tests/test_move_callback.py

@@ -1,20 +1,23 @@
 import collections
+import time
 from unittest import mock
 
 import pytest
 
 from bec_ipython_client.callbacks.move_device import (
     LiveUpdatesReadbackProgressbar,
-    ReadbackDataMixin,
+    ReadbackDataHandler,
 )
 from bec_lib import messages
 from bec_lib.endpoints import MessageEndpoints
 
 
 @pytest.fixture
-def readback_data_mixin(bec_client_mock):
-    with mock.patch.object(bec_client_mock.device_manager, "connector"):
-        yield ReadbackDataMixin(bec_client_mock.device_manager, ["samx", "samy"])
+def readback_data_handler(bec_client_mock, connected_connector):
+    with mock.patch.object(bec_client_mock.device_manager, "connector", connected_connector):
+        yield ReadbackDataHandler(
+            bec_client_mock.device_manager, ["samx", "samy"], request_id="something"
+        )
 
 
 def test_move_callback(bec_client_mock):
@@ -33,30 +36,25 @@ def test_move_callback(bec_client_mock):
         return readback[0]
 
     req_done = collections.deque()
-    msg_acc = messages.DeviceReqStatusMessage(
-        device="samx", success=True, metadata={"RID": "something"}
-    )
-    req_done.extend([[None], [None], [None], [msg_acc]])
+    req_done.extend([{"samx": (False, False)}, {"samx": (False, False)}, {"samx": (True, True)}])
 
     def mock_req_msg(*args):
         if len(req_done) > 1:
             return req_done.popleft()
         return req_done[0]
 
-    with mock.patch("bec_ipython_client.callbacks.move_device.check_alarms") as check_alarms_mock:
-        with mock.patch.object(ReadbackDataMixin, "wait_for_RID"):
-            with mock.patch.object(LiveUpdatesReadbackProgressbar, "wait_for_request_acceptance"):
+    with mock.patch("bec_ipython_client.callbacks.move_device.check_alarms"):
+        with mock.patch.object(LiveUpdatesReadbackProgressbar, "wait_for_request_acceptance"):
+            with mock.patch.object(
+                LiveUpdatesReadbackProgressbar, "_print_client_msgs_asap"
+            ) as mock_client_msgs:
                 with mock.patch.object(
-                    LiveUpdatesReadbackProgressbar, "_print_client_msgs_asap"
-                ) as mock_client_msgs:
-                    with mock.patch.object(
-                        LiveUpdatesReadbackProgressbar, "_print_client_msgs_all"
-                    ) as mock_client_msgs_all:
-                        with mock.patch.object(
-                            ReadbackDataMixin, "get_device_values", mock_readback
-                        ):
+                    LiveUpdatesReadbackProgressbar, "_print_client_msgs_all"
+                ) as mock_client_msgs_all:
+                    with mock.patch.object(ReadbackDataHandler, "get_device_values", mock_readback):
+                        with mock.patch.object(ReadbackDataHandler, "device_states", mock_req_msg):
                             with mock.patch.object(
-                                ReadbackDataMixin, "get_request_done_msgs", mock_req_msg
+                                ReadbackDataHandler, "done", side_effect=[False, False, True]
                             ):
                                 LiveUpdatesReadbackProgressbar(bec=client, request=request).run()
                                 assert mock_client_msgs.called is True
@@ -82,28 +80,21 @@ def test_move_callback_with_report_instruction(bec_client_mock):
         return readback[0]
 
     req_done = collections.deque()
-    msg_acc = messages.DeviceReqStatusMessage(
-        device="samx", success=True, metadata={"RID": "something"}
-    )
-    req_done.extend([[None], [None], [None], [msg_acc]])
+    req_done.extend([{"samx": (False, False)}, {"samx": (False, False)}, {"samx": (True, True)}])
 
     def mock_req_msg(*args):
         if len(req_done) > 1:
             return req_done.popleft()
         return req_done[0]
 
-    with mock.patch("bec_ipython_client.callbacks.move_device.check_alarms") as check_alarms_mock:
-        with mock.patch.object(ReadbackDataMixin, "wait_for_RID"):
-            with mock.patch.object(LiveUpdatesReadbackProgressbar, "wait_for_request_acceptance"):
-                with mock.patch.object(LiveUpdatesReadbackProgressbar, "_print_client_msgs_asap"):
-                    with mock.patch.object(
-                        LiveUpdatesReadbackProgressbar, "_print_client_msgs_all"
-                    ):
-                        with mock.patch.object(
-                            ReadbackDataMixin, "get_device_values", mock_readback
-                        ):
+    with mock.patch("bec_ipython_client.callbacks.move_device.check_alarms"):
+        with mock.patch.object(LiveUpdatesReadbackProgressbar, "wait_for_request_acceptance"):
+            with mock.patch.object(LiveUpdatesReadbackProgressbar, "_print_client_msgs_asap"):
+                with mock.patch.object(LiveUpdatesReadbackProgressbar, "_print_client_msgs_all"):
+                    with mock.patch.object(ReadbackDataHandler, "get_device_values", mock_readback):
+                        with mock.patch.object(ReadbackDataHandler, "device_states", mock_req_msg):
                             with mock.patch.object(
-                                ReadbackDataMixin, "get_request_done_msgs", mock_req_msg
+                                ReadbackDataHandler, "done", side_effect=[False, False, False, True]
                             ):
                                 LiveUpdatesReadbackProgressbar(
                                     bec=client,
@@ -112,70 +103,121 @@ def test_move_callback_with_report_instruction(bec_client_mock):
                                 ).run()
 
 
-def test_readback_data_mixin(readback_data_mixin):
-    readback_data_mixin.device_manager.connector.get.side_effect = [
-        messages.DeviceMessage(
+def test_readback_data_handler(readback_data_handler):
+    readback_data_handler.data = {
+        "samx": messages.DeviceMessage(
             signals={"samx": {"value": 10}, "samx_setpoint": {"value": 20}},
             metadata={"device": "samx"},
         ),
-        messages.DeviceMessage(
+        "samy": messages.DeviceMessage(
             signals={"samy": {"value": 10}, "samy_setpoint": {"value": 20}},
             metadata={"device": "samy"},
         ),
-    ]
-    res = readback_data_mixin.get_device_values()
+    }
+
+    res = readback_data_handler.get_device_values()
     assert res == [10, 10]
 
 
-def test_readback_data_mixin_multiple_hints(readback_data_mixin):
-    readback_data_mixin.device_manager.devices.samx._info["hints"]["fields"] = [
+def test_readback_data_handler_multiple_hints(readback_data_handler):
+    readback_data_handler.device_manager.devices.samx._info["hints"]["fields"] = [
         "samx_setpoint",
         "samx",
     ]
-    readback_data_mixin.device_manager.connector.get.side_effect = [
-        messages.DeviceMessage(
+    readback_data_handler.data = {
+        "samx": messages.DeviceMessage(
             signals={"samx": {"value": 10}, "samx_setpoint": {"value": 20}},
             metadata={"device": "samx"},
         ),
-        messages.DeviceMessage(
+        "samy": messages.DeviceMessage(
             signals={"samy": {"value": 10}, "samy_setpoint": {"value": 20}},
             metadata={"device": "samy"},
         ),
-    ]
-    res = readback_data_mixin.get_device_values()
+    }
+    res = readback_data_handler.get_device_values()
     assert res == [20, 10]
 
 
-def test_readback_data_mixin_multiple_no_hints(readback_data_mixin):
-    readback_data_mixin.device_manager.devices.samx._info["hints"]["fields"] = []
-    readback_data_mixin.device_manager.connector.get.side_effect = [
-        messages.DeviceMessage(
+def test_readback_data_handler_multiple_no_hints(readback_data_handler):
+    readback_data_handler.device_manager.devices.samx._info["hints"]["fields"] = []
+    readback_data_handler.data = {
+        "samx": messages.DeviceMessage(
             signals={"samx": {"value": 10}, "samx_setpoint": {"value": 20}},
             metadata={"device": "samx"},
         ),
-        messages.DeviceMessage(
+        "samy": messages.DeviceMessage(
             signals={"samy": {"value": 10}, "samy_setpoint": {"value": 20}},
             metadata={"device": "samy"},
         ),
-    ]
-    res = readback_data_mixin.get_device_values()
+    }
+    res = readback_data_handler.get_device_values()
     assert res == [10, 10]
 
 
-def test_get_request_done_msgs(readback_data_mixin):
-    res = readback_data_mixin.get_request_done_msgs()
-    readback_data_mixin.device_manager.connector.pipeline.assert_called_once()
-    assert (
-        mock.call(
-            MessageEndpoints.device_req_status("samx"),
-            readback_data_mixin.device_manager.connector.pipeline.return_value,
-        )
-        in readback_data_mixin.device_manager.connector.get.call_args_list
+def test_readback_data_handler_init(readback_data_handler):
+    """
+    Test that the ReadbackDataHandler is initialized correctly.
+    """
+
+    # Initial state
+    assert readback_data_handler._devices_done_state == {
+        "samx": (False, False),
+        "samy": (False, False),
+    }
+    assert readback_data_handler._devices_received == {"samx": False, "samy": False}
+    assert readback_data_handler.data == {}
+
+
+def test_readback_data_handler_readback_callbacks(readback_data_handler):
+    """
+    Test that the readback callback properly updates the readback data.
+    """
+
+    # Submit readback for samx
+    msg = messages.DeviceMessage(
+        signals={"samx": {"value": 15}}, metadata={"device": "samx", "RID": "something"}
     )
-    assert (
-        mock.call(
-            MessageEndpoints.device_req_status("samy"),
-            readback_data_mixin.device_manager.connector.pipeline.return_value,
-        )
-        in readback_data_mixin.device_manager.connector.get.call_args_list
+    readback_data_handler.connector.set_and_publish(MessageEndpoints.device_readback("samx"), msg)
+
+    msg_old = messages.DeviceMessage(
+        signals={"samy": {"value": 10}}, metadata={"device": "samx", "RID": "something_else"}
+    )
+    readback_data_handler.connector.set_and_publish(
+        MessageEndpoints.device_readback("samy"), msg_old
+    )
+    while (
+        not readback_data_handler._devices_received["samx"]
+        or "samx" not in readback_data_handler.data
+    ):
+        time.sleep(0.01)
+    assert readback_data_handler.data["samx"].signals["samx"]["value"] == 15
+    dev_data = readback_data_handler.get_device_values()
+    assert dev_data[0] == 15
+    assert dev_data[1] == 10  # samy remains unchanged
+
+
+def test_readback_data_handler_request_done_callbacks(readback_data_handler):
+    """
+    Test that the request done callback properly updates the device done state.
+    """
+
+    # Submit request done for samx
+    msg = messages.DeviceReqStatusMessage(device="samx", success=True, request_id="something")
+    readback_data_handler.connector.xadd(
+        MessageEndpoints.device_req_status("something"), {"data": msg}
+    )
+    while not readback_data_handler._devices_done_state["samx"][0]:
+        time.sleep(0.01)
+    assert readback_data_handler._devices_done_state["samx"] == (True, True)
+
+    assert readback_data_handler.done() is False
+
+    # Submit request done for samy
+    msg = messages.DeviceReqStatusMessage(device="samy", success=False, request_id="something")
+    readback_data_handler.connector.xadd(
+        MessageEndpoints.device_req_status("something"), {"data": msg}
     )
+    while not readback_data_handler._devices_done_state["samy"][0]:
+        time.sleep(0.01)
+    assert readback_data_handler._devices_done_state["samy"] == (True, False)
+    assert readback_data_handler.done() is True