bec-ipython-client 3.64.1__py3-none-any.whl → 3.86.1__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

@@ -0,0 +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
+
+image_name = (
+    f"ghcr.io/bec-project/{PROCEDURE.CONTAINER.REQUIREMENTS_IMAGE_NAME}:v{PROCEDURE.BEC_VERSION}"
+)
+podman = PodmanCliUtils()
+
+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 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,7 +12,7 @@ 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.constants import _CONTAINER, _WORKER
 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
@@ -28,6 +29,15 @@ 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"],
@@ -52,7 +62,7 @@ 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')}")
 
 
@@ -62,7 +72,7 @@ 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"
@@ -77,21 +87,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 != {}, 20)
 
     assert logs != []
 
 
 @pytest.mark.timeout(100)
 @patch("bec_server.scan_server.procedures.manager.procedure_registry.is_registered", lambda _: True)
+@patch("bec_server.scan_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 +110,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 != {}, 20)
 
     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 +128,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)

tests/end-2-end/test_scans_lib_e2e.py

@@ -108,12 +108,10 @@ def test_config_updates(bec_client_lib):
     assert dev.rt_controller.limits == [-50, 50]
 
     dev.rt_controller.velocity.set(10).wait()
+    assert dev.rt_controller.velocity.read(cached=True)["rt_controller_velocity"]["value"] == 10
     assert dev.rt_controller.velocity.read()["rt_controller_velocity"]["value"] == 10
-    assert dev.rt_controller.velocity.read(cached=False)["rt_controller_velocity"]["value"] == 10
     assert dev.rt_controller.read_configuration()["rt_controller_velocity"]["value"] == 10
-    assert (
-        dev.rt_controller.read_configuration(cached=False)["rt_controller_velocity"]["value"] == 10
-    )
+    assert dev.rt_controller.read_configuration()["rt_controller_velocity"]["value"] == 10
 
     dev.rt_controller.velocity.put(5)
     assert dev.rt_controller.velocity.get() == 5
@@ -324,7 +322,9 @@ def test_config_reload(
     num_devices = len(bec.device_manager.devices)
     if raises_error:
         with pytest.raises(DeviceConfigError):
-            bec.config.update_session_with_file(runtime_config_file_path)
+            bec.config.update_session_with_file(
+                runtime_config_file_path, force=True, validate=False
+            )
         if deletes_config:
             assert len(bec.device_manager.devices) == 0
         elif disabled_device:
@@ -332,7 +332,7 @@ def test_config_reload(
         else:
             assert len(bec.device_manager.devices) == num_devices
     else:
-        bec.config.update_session_with_file(runtime_config_file_path)
+        bec.config.update_session_with_file(runtime_config_file_path, force=True, validate=False)
         assert len(bec.device_manager.devices) == 2
     for dev in disabled_device:
         assert bec.device_manager.devices[dev].enabled is False
@@ -377,7 +377,7 @@ def test_config_reload_with_describe_failure(bec_test_config_file_path, bec_clie
         f.write(yaml.dump(config))
 
     with pytest.raises(DeviceConfigError):
-        bec.config.update_session_with_file(runtime_config_file_path)
+        bec.config.update_session_with_file(runtime_config_file_path, force=True, validate=False)
 
     assert len(bec.device_manager.devices) == 2
     assert bec.device_manager.devices["eyefoc"].enabled is True
@@ -388,7 +388,7 @@ def test_config_reload_with_describe_failure(bec_test_config_file_path, bec_clie
         f"e2e_test_hexapod_fail", messages.DeviceStatusMessage(device="hexapod", status=0)
     )
 
-    bec.config.update_session_with_file(runtime_config_file_path)
+    bec.config.update_session_with_file(runtime_config_file_path, force=True)
     assert len(bec.device_manager.devices) == 2
     assert bec.device_manager.devices["eyefoc"].enabled is True
     assert bec.device_manager.devices["hexapod"].enabled is True
@@ -414,13 +414,13 @@ def test_config_add_remove_device(bec_client_lib):
             "readOnly": False,
         }
     }
-    bec.config.send_config_request(action="add", config=config)
+    bec.device_manager.config_helper.send_config_request(action="add", config=config)
     with pytest.raises(DeviceConfigError) as config_error:
-        bec.config.send_config_request(action="add", config=config)
+        bec.device_manager.config_helper.send_config_request(action="add", config=config)
     assert config_error.match("Device new_device already exists")
     assert "new_device" in dev
 
-    bec.config.send_config_request(action="remove", config={"new_device": {}})
+    bec.device_manager.config_helper.send_config_request(action="remove", config={"new_device": {}})
     assert "new_device" not in dev
 
     device_config_msg = bec.connector.get(MessageEndpoints.device_config())
@@ -431,7 +431,7 @@ def test_config_add_remove_device(bec_client_lib):
 
     config["new_device"]["deviceClass"] = "ophyd_devices.doesnt_exist"
     with pytest.raises(DeviceConfigError) as config_error:
-        bec.config.send_config_request(action="add", config=config)
+        bec.device_manager.config_helper.send_config_request(action="add", config=config)
     assert config_error.match("module 'ophyd_devices' has no attribute 'doesnt_exist'")
     assert "new_device" not in dev
     assert "samx" in dev
@@ -454,7 +454,7 @@ def test_computed_signal(bec_client_lib):
     dev.pseudo_signal1.set_compute_method(compute_signal1)
     dev.pseudo_signal1.set_input_signals()
 
-    assert dev.pseudo_signal1.read(cached=False)["pseudo_signal1"]["value"] == 5
+    assert dev.pseudo_signal1.read()["pseudo_signal1"]["value"] == 5
 
 
 def test_cached_device_readout(bec_client_lib):
@@ -463,26 +463,30 @@ def test_cached_device_readout(bec_client_lib):
     dev = bec.device_manager.devices
 
     dev.samx.setpoint.put(5)
-    data = dev.samx.setpoint.get()
+    data = dev.samx.setpoint.get(cached=True)
     assert data == 5
 
-    orig_velocity = dev.samx.velocity.get()
+    orig_velocity = dev.samx.velocity.get(cached=True)
     dev.samx.velocity.put(10)
-    data = dev.samx.velocity.get()
+    data = dev.samx.velocity.get(cached=True)
     assert data == 10
 
-    config = dev.samx.read_configuration()
+    config = dev.samx.read_configuration(cached=True)
     assert config["samx_velocity"]["value"] == 10
 
+    dev.samx.velocity.set(20).wait()
+    data = dev.samx.velocity.get(cached=True)
+    assert data == 20
+
     dev.samx.velocity.put(orig_velocity)
 
-    data = dev.hexapod.x.readback.read(cached=False)
+    data = dev.hexapod.x.readback.read()
     timestamp = data["hexapod_x"]["timestamp"]
     data = dev.hexapod.x.readback.read(cached=True)
     assert data["hexapod_x"]["timestamp"] == timestamp
 
     # check that .get also updates the cache
-    dev.hexapod.x.readback.get(cached=False)
+    dev.hexapod.x.readback.get()
     timestamp_2 = dev.hexapod.x.readback.read(cached=True)["hexapod_x"]["timestamp"]
     assert timestamp_2 != timestamp