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

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

@@ -737,12 +737,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