refactor: generalize sim_mode

ophyd_devices/epics/devices/bec_scaninfo_mixin.py

@@ -6,23 +6,70 @@ from bec_lib.core import bec_logger
 logger = bec_logger.logger
 
 
+class Bec_Info_Msg_Mock:
+    def __init__(
+        self,
+        mockrid: str = "mockrid1111",
+        mockqueueid: str = "mockqueueID111",
+        scan_number: int = 1,
+        exp_time: float = 12e-3,
+        num_points: int = 500,
+        readout_time: float = 3e-3,
+        scan_type: str = "fly",
+        num_lines: int = 1,
+        frames_per_trigger: int = 1,
+    ) -> None:
+        self.mockrid = mockrid
+        self.mockqueueid = mockqueueid
+        self.scan_number = scan_number
+        self.exp_time = exp_time
+        self.num_points = num_points
+        self.readout_time = readout_time
+        self.scan_type = scan_type
+        self.num_lines = num_lines
+        self.frames_per_trigger = frames_per_trigger
+
+    def get_bec_info_msg(self) -> dict:
+        info_msg = {
+            "RID": self.mockrid,
+            "queueID": self.mockqueueid,
+            "scan_number": self.scan_number,
+            "exp_time": self.exp_time,
+            "num_points": self.num_points,
+            "readout_time": self.readout_time,
+            "scan_type": self.scan_type,
+            "num_lines": self.exp_time,
+            "frames_per_trigger": self.frames_per_trigger,
+        }
+
+        return info_msg
+
+
 class BecScaninfoMixin:
-    def __init__(self, device_manager: DeviceManagerBase = None, sim_mode=False) -> None:
+    def __init__(
+        self, device_manager: DeviceManagerBase = None, sim_mode: bool = False, bec_info_msg=None
+    ) -> None:
         self.device_manager = device_manager
         self.sim_mode = sim_mode
         self.scan_msg = None
         self.scanID = None
-        self.bec_info_msg = {
-            "RID": "mockrid",
-            "queueID": "mockqueuid",
-            "scan_number": 1,
-            "exp_time": 12e-3,
-            "num_points": 500,
-            "readout_time": 3e-3,
-            "scan_type": "fly",
-            "num_lines": 1,
-            "frames_per_trigger": 1,
-        }
+        if bec_info_msg is None:
+            bec_info_msg_mock = Bec_Info_Msg_Mock()
+            self.bec_info_msg = bec_info_msg_mock.get_bec_info_msg()
+        else:
+            self.bec_info_msg = bec_info_msg
+
+        # self.bec_info_msg = {
+        #     "RID": "mockrid",
+        #     "queueID": "mockqueuid",
+        #     "scan_number": 1,
+        #     "exp_time": 12e-3,
+        #     "num_points": 500,
+        #     "readout_time": 3e-3,
+        #     "scan_type": "fly",
+        #     "num_lines": 1,
+        #     "frames_per_trigger": 1,
+        # }
 
     def get_bec_info_msg(self) -> None:
         return self.bec_info_msg

ophyd_devices/epics/devices/eiger9m_csaxs.py

@@ -143,15 +143,11 @@ class Eiger9mCsaxs(DetectorBase):
         if not sim_mode:
             self._update_service_config()
             self.device_manager = device_manager
-            self._producer = self.device_manager.producer
         else:
-            self._producer = bec_utils.MockProducer()
-            self.device_manager = bec_utils.MockDeviceManager()
-            self.scaninfo = BecScaninfoMixin(device_manager, sim_mode)
-            self.scaninfo.load_scan_metadata()
-            base_path = f"/sls/X12SA/data/{self.scaninfo.username}/Data10/"
-            self.service_cfg = {"base_path": base_path}
-
+            self.device_manager = bec_utils.DMMock()
+            base_path = f"~/Data10/"
+            self.service_cfg = {"base_path": os.path.expanduser(base_path)}
+        self._producer = self.device_manager.producer
         self.scaninfo = BecScaninfoMixin(device_manager, sim_mode)
         self.scaninfo.load_scan_metadata()
         self.filewriter = FileWriterMixin(self.service_cfg)

ophyd_devices/utils/bec_utils.py

@@ -1,6 +1,8 @@
 import time
 
 from bec_lib.core import bec_logger
+from bec_lib.core.devicemanager import DeviceContainer
+from bec_lib.core.tests.utils import ProducerMock
 
 from ophyd import Signal, Kind
 
@@ -11,33 +13,88 @@ logger = bec_logger.logger
 DEFAULT_EPICSSIGNAL_VALUE = object()
 
 
-class MockProducer:
-    def set_and_publish(self, endpoint: str, msgdump: str):
-        logger.info(f"BECMessage to {endpoint} with msg dump {msgdump}")
-
-
-class MockDeviceManager:
-    def __init__(self) -> None:
-        self.devices = devices()
-
-
-class OphydObject:
-    def __init__(self) -> None:
-        self.name = "mock_mokev"
-        self.obj = mokev()
-
-
-class devices:
-    def __init__(self):
-        self.mokev = OphydObject()
-
-
-class mokev:
-    def __init__(self):
-        self.name = "mock_mokev"
+# TODO maybe specify here that this DeviceMock is for usage in the DeviceServer
+class DeviceMock:
+    def __init__(self, name: str, value: float = 0.0):
+        self.name = name
+        self.read_buffer = value
+        self._config = {"deviceConfig": {"limits": [-50, 50]}, "userParameter": None}
+        self._enabled_set = True
+        self._enabled = True
 
     def read(self):
-        return {self.name: {"value": 16.0, "timestamp": time.time()}}
+        return {self.name: {"value": self.read_buffer}}
+
+    def readback(self):
+        return self.read_buffer
+
+    @property
+    def enabled_set(self) -> bool:
+        return self._enabled_set
+
+    @enabled_set.setter
+    def enabled_set(self, val: bool):
+        self._enabled_set = val
+
+    @property
+    def enabled(self) -> bool:
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, val: bool):
+        self._enabled = val
+
+    @property
+    def user_parameter(self):
+        return self._config["userParameter"]
+
+    @property
+    def obj(self):
+        return self
+
+
+class DMMock:
+    """Mock for DeviceManager
+
+    The mocked DeviceManager creates a device containert and a producer.
+
+    """
+
+    def __init__(self):
+        self.devices = DeviceContainer()
+        self.producer = ProducerMock()
+
+    def add_device(self, name: str, value: float = 0.0):
+        self.devices[name] = DeviceMock(name, value)
+
+
+# class MockProducer:
+#     def set_and_publish(self, endpoint: str, msgdump: str):
+#         logger.info(f"BECMessage to {endpoint} with msg dump {msgdump}")
+
+
+# class MockDeviceManager:
+#     def __init__(self) -> None:
+#         self.devices = devices()
+
+
+# class OphydObject:
+#     def __init__(self) -> None:
+#         self.name = "mock_mokev"
+#         self.obj = mokev()
+
+
+# class devices:
+#     def __init__(self):
+#         self.mokev = OphydObject()
+
+
+# class mokev:
+#     def __init__(self):
+#         self.name = "mock_mokev"
+
+#     def read(self):
+#         return {self.name: {"value": 16.0, "timestamp": time.time()}}
 
 
 class ConfigSignal(Signal):