bec-ipython-client 3.64.5__py3-none-any.whl → 3.89.3__py3-none-any.whl

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

tests/end-2-end/_ensure_requirements_container.py

@@ -1,21 +1,21 @@
 from time import sleep
 
-from bec_server.scan_server.procedures.constants import PROCEDURE, ProcedureWorkerError
-from bec_server.scan_server.procedures.container_utils import PodmanCliUtils
+from bec_server.procedures.constants import PROCEDURE, ProcedureWorkerError
+from bec_server.procedures.container_utils import PodmanCliUtils
 
 image_name = (
     f"ghcr.io/bec-project/{PROCEDURE.CONTAINER.REQUIREMENTS_IMAGE_NAME}:v{PROCEDURE.BEC_VERSION}"
 )
 podman = PodmanCliUtils()
 
-for i in range(1, 4):
+for i in range(1, 6):
     try:
         output = podman._run_and_capture_error("podman", "pull", image_name)
         print("successfully pulled requirements image for current version")
         exit(0)
     except ProcedureWorkerError as e:
         print(e)
-        print("retrying in 2 minutes...")
-        sleep(120)
+        print("retrying in 5 minutes...")
+        sleep(5 * 60)
 print(f"No more retries. Check if {image_name} actually exists!")
 exit(1)

tests/end-2-end/test_procedures_e2e.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import time
+from dataclasses import dataclass
 from importlib.metadata import version
 from typing import TYPE_CHECKING, Callable, Generator
 from unittest.mock import MagicMock, patch
@@ -11,10 +12,10 @@ from bec_ipython_client.main import BECIPythonClient
 from bec_lib import messages
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
-from bec_server.scan_server.procedures.constants import PROCEDURE
-from bec_server.scan_server.procedures.container_utils import get_backend
-from bec_server.scan_server.procedures.container_worker import ContainerProcedureWorker
-from bec_server.scan_server.procedures.manager import ProcedureManager
+from bec_server.procedures.constants import _CONTAINER, _WORKER
+from bec_server.procedures.container_utils import get_backend
+from bec_server.procedures.container_worker import ContainerProcedureWorker
+from bec_server.procedures.manager import ProcedureManager
 
 if TYPE_CHECKING:
     from pytest_bec_e2e.plugin import LogTestTool
@@ -28,14 +29,23 @@ logger = bec_logger.logger
 pytestmark = pytest.mark.random_order(disabled=True)
 
 
+@dataclass(frozen=True)
+class PATCHED_CONSTANTS:
+    WORKER = _WORKER()
+    CONTAINER = _CONTAINER()
+    MANAGER_SHUTDOWN_TIMEOUT_S = 2
+    BEC_VERSION = version("bec_lib")
+    REDIS_HOST = "localhost"
+
+
 @pytest.fixture
 def client_logtool_and_manager(
     bec_ipython_client_fixture_with_logtool: tuple[BECIPythonClient, "LogTestTool"],
 ) -> Generator[tuple[BECIPythonClient, "LogTestTool", ProcedureManager], None, None]:
     client, logtool = bec_ipython_client_fixture_with_logtool
-    server = MagicMock()
-    server.bootstrap_server = f"{client.connector.host}:{client.connector.port}"
-    manager = ProcedureManager(server, ContainerProcedureWorker)
+    manager = ProcedureManager(
+        f"{client.connector.host}:{client.connector.port}", ContainerProcedureWorker
+    )
     yield client, logtool, manager
     manager.shutdown()
 
@@ -52,20 +62,21 @@ def _wait_while(cond: Callable[[], bool], timeout_s):
 def test_building_worker_image():
     podman_utils = get_backend()
     build = podman_utils.build_worker_image()
-    assert len(build._command_output.splitlines()[-1]) == 64
+    assert len(build._command_output.splitlines()[-1]) == 64  # type: ignore
     assert podman_utils.image_exists(f"bec_procedure_worker:v{version('bec_lib')}")
 
 
 @pytest.mark.timeout(100)
-@patch("bec_server.scan_server.procedures.manager.procedure_registry.is_registered", lambda _: True)
+@patch("bec_server.procedures.manager.procedure_registry.is_registered", lambda _: True)
+@patch("bec_server.procedures.container_worker.PROCEDURE", PATCHED_CONSTANTS())
 def test_procedure_runner_spawns_worker(
     client_logtool_and_manager: tuple[BECIPythonClient, "LogTestTool", ProcedureManager],
 ):
     client, _, manager = client_logtool_and_manager
-    assert manager.active_workers == {}
+    assert manager._active_workers == {}
     endpoint = MessageEndpoints.procedure_request()
     msg = messages.ProcedureRequestMessage(
-        identifier="sleep", args_kwargs=((), {"time_s": 2}), queue="test"
+        identifier="sleep", args_kwargs=((), {"time_s": 0.1}), queue="test"
     )
 
     logs = []
@@ -77,21 +88,22 @@ def test_procedure_runner_spawns_worker(
     manager.add_callback("test", cb)
     client.connector.xadd(topic=endpoint, msg_dict=msg.model_dump())
 
-    _wait_while(lambda: manager.active_workers == {}, 5)
-    _wait_while(lambda: manager.active_workers != {}, 20)
+    _wait_while(lambda: manager._active_workers == {}, 5)
+    _wait_while(lambda: manager._active_workers != {}, 90)
 
     assert logs != []
 
 
 @pytest.mark.timeout(100)
-@patch("bec_server.scan_server.procedures.manager.procedure_registry.is_registered", lambda _: True)
+@patch("bec_server.procedures.manager.procedure_registry.is_registered", lambda _: True)
+@patch("bec_server.procedures.container_worker.PROCEDURE", PATCHED_CONSTANTS())
 def test_happy_path_container_procedure_runner(
     client_logtool_and_manager: tuple[BECIPythonClient, "LogTestTool", ProcedureManager],
 ):
     test_args = (1, 2, 3)
     test_kwargs = {"a": "b", "c": "d"}
     client, logtool, manager = client_logtool_and_manager
-    assert manager.active_workers == {}
+    assert manager._active_workers == {}
     conn = client.connector
     endpoint = MessageEndpoints.procedure_request()
     msg = messages.ProcedureRequestMessage(
@@ -99,12 +111,15 @@ def test_happy_path_container_procedure_runner(
     )
     conn.xadd(topic=endpoint, msg_dict=msg.model_dump())
 
-    _wait_while(lambda: manager.active_workers == {}, 5)
-    _wait_while(lambda: manager.active_workers != {}, 20)
+    _wait_while(lambda: manager._active_workers == {}, 5)
+    _wait_while(lambda: manager._active_workers != {}, 90)
 
     logtool.fetch()
     assert logtool.is_present_in_any_message("procedure accepted: True, message:")
-    assert logtool.is_present_in_any_message("ContainerWorker started container for queue primary")
+    assert logtool.is_present_in_any_message(
+        "ContainerWorker started container for queue primary"
+    ), f"Log content relating to procedures: {manager._logs}"
+
     res, msg = logtool.are_present_in_order(
         [
             "Container worker 'primary' status update: IDLE",
@@ -114,12 +129,7 @@ def test_happy_path_container_procedure_runner(
         ]
     )
     assert res, f"failed on {msg}"
-    res, msg = logtool.are_present_in_order(
-        [
-            "Container worker 'primary' status update: IDLE",
-            f"Builtin procedure log_message_args_kwargs called with args: {test_args} and kwargs: {test_kwargs}",
-            "Container worker 'primary' status update: IDLE",
-            "Container worker 'primary' status update: FINISHED",
-        ]
+
+    assert logtool.is_present_in_any_message(
+        f"Builtin procedure log_message_args_kwargs called with args: {test_args} and kwargs: {test_kwargs}"
     )
-    assert res, f"failed on {msg}"

tests/end-2-end/test_scans_e2e.py

@@ -1,9 +1,12 @@
+from __future__ import annotations
+
 import _thread
 import io
 import os
 import threading
 import time
 from contextlib import redirect_stdout
+from typing import TYPE_CHECKING
 from unittest.mock import PropertyMock
 
 import h5py
@@ -19,6 +22,9 @@ from bec_lib.logger import bec_logger
 
 logger = bec_logger.logger
 
+if TYPE_CHECKING:  # pragma: no cover
+    from bec_ipython_client.main import BECIPythonClient
+
 # pylint: disable=protected-access
 
 
@@ -201,13 +207,13 @@ def test_mv_scan_mv(bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_scan_abort(bec_ipython_client_fixture):
+def test_scan_abort(bec_ipython_client_fixture: BECIPythonClient):
     def send_abort(bec):
         while True:
             current_scan_info = bec.queue.scan_storage.current_scan_info
             if not current_scan_info:
                 continue
-            status = current_scan_info.get("status").lower()
+            status = current_scan_info.status.lower()
             if status not in ["running", "deferred_pause"]:
                 continue
             if bec.queue.scan_storage.current_scan is None:
@@ -217,7 +223,7 @@ def test_scan_abort(bec_ipython_client_fixture):
                 break
         while True:
             queue = bec.queue.queue_storage.current_scan_queue
-            if queue["primary"]["info"][0]["status"] == "DEFERRED_PAUSE":
+            if queue["primary"].info[0].status == "DEFERRED_PAUSE":
                 break
             time.sleep(0.5)
         _thread.interrupt_main()
@@ -241,7 +247,7 @@ def test_scan_abort(bec_ipython_client_fixture):
         time.sleep(0.5)
 
     current_queue = bec.queue.queue_storage.current_scan_queue["primary"]
-    while current_queue["info"] or current_queue["status"] != "RUNNING":
+    while current_queue.info or current_queue.status != "RUNNING":
         time.sleep(0.5)
         current_queue = bec.queue.queue_storage.current_scan_queue["primary"]
 
@@ -307,7 +313,7 @@ def test_queued_scan(bec_ipython_client_fixture):
     while len(scan2.scan.live_data) != 50:
         time.sleep(0.5)
     current_queue = bec.queue.queue_storage.current_scan_queue["primary"]
-    while current_queue["info"] or current_queue["status"] != "RUNNING":
+    while current_queue.info or current_queue.status != "RUNNING":
         time.sleep(0.5)
         current_queue = bec.queue.queue_storage.current_scan_queue["primary"]
     scan_number_end = bec.queue.next_scan_number
@@ -356,7 +362,7 @@ def test_scan_restart(bec_ipython_client_fixture):
     scan2.wait()
 
     current_queue = bec.queue.queue_storage.current_scan_queue["primary"]
-    while current_queue["info"] or current_queue["status"] != "RUNNING":
+    while current_queue.info or current_queue.status != "RUNNING":
         time.sleep(0.5)
         current_queue = bec.queue.queue_storage.current_scan_queue["primary"]
     scan_number_end = bec.queue.next_scan_number
@@ -364,7 +370,7 @@ def test_scan_restart(bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_scan_observer_repeat_queued(bec_ipython_client_fixture):
+def test_scan_observer_repeat_queued(bec_ipython_client_fixture: BECIPythonClient):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_scan_observer_repeat_queued"})
     scans = bec.scans
@@ -396,7 +402,7 @@ def test_scan_observer_repeat_queued(bec_ipython_client_fixture):
     scan2.wait()
 
     current_queue = bec.queue.queue_storage.current_scan_queue["primary"]
-    while current_queue["info"] or current_queue["status"] != "RUNNING":
+    while current_queue.info or current_queue.status != "RUNNING":
         time.sleep(0.5)
         current_queue = bec.queue.queue_storage.current_scan_queue["primary"]
     scan_number_end = bec.queue.next_scan_number
@@ -433,7 +439,7 @@ def test_scan_observer_repeat(bec_ipython_client_fixture):
         scan1.wait()
 
     current_queue = bec.queue.queue_storage.current_scan_queue["primary"]
-    while current_queue["info"] or current_queue["status"] != "RUNNING":
+    while current_queue.info or current_queue.status != "RUNNING":
         time.sleep(0.5)
         current_queue = bec.queue.queue_storage.current_scan_queue["primary"]
     while True:
@@ -737,12 +743,12 @@ def test_update_config(bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_update_config"})
     demo_config_path = os.path.join(os.path.dirname(configs.__file__), "demo_config.yaml")
-    config = bec.config._load_config_from_file(demo_config_path)
+    config = bec.device_manager.config_helper._load_config_from_file(demo_config_path)
     config.pop("samx")
-    bec.config.send_config_request(action="set", config=config)
+    bec.device_manager.config_helper.send_config_request(action="set", config=config)
     assert "samx" not in bec.device_manager.devices
-    config = bec.config._load_config_from_file(demo_config_path)
-    bec.config.send_config_request(action="set", config=config)
+    config = bec.device_manager.config_helper._load_config_from_file(demo_config_path)
+    bec.device_manager.config_helper.send_config_request(action="set", config=config)
 
 
 @pytest.mark.timeout(100)
@@ -819,3 +825,46 @@ def test_client_info_message(bec_ipython_client_fixture):
         s1 = scans.line_scan(dev.samx, 0, 1, steps=10, exp_time=0.5, relative=False)
         output = buffer.getvalue()
         assert "test_client_info_message" in output
+
+
+@pytest.mark.timeout(100)
+def test_device_progress_grid_scan(bec_ipython_client_fixture, capsys):
+    bec = bec_ipython_client_fixture
+    scans = bec.scans
+    bec.metadata.update({"unit_test": "test_device_progress_grid_scan"})
+    dev = bec.device_manager.devices
+    scans.device_progress_grid_scan(
+        dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, relative=True, exp_time=0.01
+    )
+    captured = capsys.readouterr()
+    assert "bpm4i" not in captured.out
+    assert "samx" not in captured.out
+    assert "Scan" in captured.out
+    assert "100 %" in captured.out
+
+
+@pytest.mark.timeout(100)
+def test_grid_scan_secondary_queue(capsys, bec_ipython_client_fixture):
+    bec = bec_ipython_client_fixture
+    scans = bec.scans
+    bec.metadata.update({"unit_test": "test_grid_scan_secondary_queue"})
+    dev = bec.device_manager.devices
+    status = scans.grid_scan(
+        dev.samx,
+        -5,
+        5,
+        10,
+        dev.samy,
+        -5,
+        5,
+        10,
+        exp_time=0.01,
+        relative=False,
+        scan_queue="secondary",
+    )
+    assert len(status.scan.live_data) == 100
+    assert status.scan.num_points == 100
+    captured = capsys.readouterr()
+    assert "finished. Scan ID" in captured.out
+
+    assert "secondary" in bec.queue.queue_storage.current_scan_queue