bec-widgets 0.99.8__py3-none-any.whl → 0.99.9__py3-none-any.whl

tests/unit_tests/client_mocks.py

@@ -1,189 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-from unittest.mock import MagicMock, patch
-
-import fakeredis
-import pytest
-from bec_lib.client import BECClient
-from bec_lib.device import Positioner, ReadoutPriority
-from bec_lib.devicemanager import DeviceContainer
-from bec_lib.redis_connector import RedisConnector
-
-
-class FakeDevice:
-    """Fake minimal positioner class for testing."""
-
-    def __init__(self, name, enabled=True, readout_priority=ReadoutPriority.MONITORED):
-        self.name = name
-        self.enabled = enabled
-        self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
-        self.readout_priority = readout_priority
-        self._config = {
-            "readoutPriority": "baseline",
-            "deviceClass": "ophyd_devices.SimPositioner",
-            "deviceConfig": {
-                "delay": 1,
-                "limits": [-50, 50],
-                "tolerance": 0.01,
-                "update_frequency": 400,
-            },
-            "deviceTags": ["user motors"],
-            "enabled": enabled,
-            "readOnly": False,
-            "name": self.name,
-        }
-
-    def __contains__(self, item):
-        return item == self.name
-
-    @property
-    def _hints(self):
-        return [self.name]
-
-    def set_value(self, fake_value: float = 1.0) -> None:
-        """
-        Setup fake value for device readout
-        Args:
-            fake_value(float): Desired fake value
-        """
-        self.signals[self.name]["value"] = fake_value
-
-    def describe(self) -> dict:
-        """
-        Get the description of the device
-        Returns:
-            dict: Description of the device
-        """
-        return self.description
-
-
-class FakePositioner(FakeDevice):
-    def __init__(
-        self,
-        name,
-        enabled=True,
-        limits=None,
-        read_value=1.0,
-        readout_priority=ReadoutPriority.MONITORED,
-    ):
-        super().__init__(name, enabled, readout_priority)
-        self.limits = limits if limits is not None else [0, 0]
-        self.read_value = read_value
-        self.name = name
-
-    @property
-    def precision(self):
-        return 3
-
-    def set_read_value(self, value):
-        self.read_value = value
-
-    def read(self):
-        return {
-            self.name: {"value": self.read_value},
-            f"{self.name}_setpoint": {"value": self.read_value},
-            f"{self.name}_motor_is_moving": {"value": 0},
-        }
-
-    def set_limits(self, limits):
-        self.limits = limits
-
-    def move(self, value, relative=False):
-        """Simulates moving the device to a new position."""
-        if relative:
-            self.read_value += value
-        else:
-            self.read_value = value
-        # Respect the limits
-        self.read_value = max(min(self.read_value, self.limits[1]), self.limits[0])
-
-    @property
-    def readback(self):
-        return MagicMock(get=MagicMock(return_value=self.read_value))
-
-
-class Positioner(FakePositioner):
-    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
-
-    def __init__(self, name="test", limits=None, read_value=1.0):
-        super().__init__(name, limits, read_value)
-
-
-class Device(FakeDevice):
-    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
-
-    def __init__(self, name, enabled=True):
-        super().__init__(name, enabled)
-
-
-class DMMock:
-    def __init__(self):
-        self.devices = DeviceContainer()
-
-    def add_devives(self, devices: list):
-        for device in devices:
-            self.devices[device.name] = device
-
-
-DEVICES = [
-    FakePositioner("samx", limits=[-10, 10], read_value=2.0),
-    FakePositioner("samy", limits=[-5, 5], read_value=3.0),
-    FakePositioner("samz", limits=[-8, 8], read_value=4.0),
-    FakePositioner("aptrx", limits=None, read_value=4.0),
-    FakePositioner("aptry", limits=None, read_value=5.0),
-    FakeDevice("gauss_bpm"),
-    FakeDevice("gauss_adc1"),
-    FakeDevice("gauss_adc2"),
-    FakeDevice("gauss_adc3"),
-    FakeDevice("bpm4i"),
-    FakeDevice("bpm3a"),
-    FakeDevice("bpm3i"),
-    FakeDevice("eiger"),
-    FakeDevice("async_device", readout_priority=ReadoutPriority.ASYNC),
-    Positioner("test", limits=[-10, 10], read_value=2.0),
-    Device("test_device"),
-]
-
-
-def fake_redis_server(host, port):
-    redis = fakeredis.FakeRedis()
-    return redis
-
-
-@pytest.fixture(scope="function")
-def mocked_client(bec_dispatcher):
-    connector = RedisConnector("localhost:1", redis_cls=fake_redis_server)
-    # Create a MagicMock object
-    client = MagicMock()  # TODO change to real BECClient
-
-    # Shutdown the original client
-    bec_dispatcher.client.shutdown()
-    # Mock the connector attribute
-    bec_dispatcher.client = client
-
-    # Mock the device_manager.devices attribute
-    client.connector = connector
-    client.device_manager = DMMock()
-    client.device_manager.add_devives(DEVICES)
-
-    def mock_mv(*args, relative=False):
-        # Extracting motor and value pairs
-        for i in range(0, len(args), 2):
-            motor = args[i]
-            value = args[i + 1]
-            motor.move(value, relative=relative)
-        return MagicMock(wait=MagicMock())
-
-    client.scans = MagicMock(mv=mock_mv)
-
-    # Ensure isinstance check for Positioner passes
-    original_isinstance = isinstance
-
-    def isinstance_mock(obj, class_info):
-        if class_info == Positioner and isinstance(obj, FakePositioner):
-            return True
-        return original_isinstance(obj, class_info)
-
-    with patch("builtins.isinstance", new=isinstance_mock):
-        yield client
-    connector.shutdown()  # TODO change to real BECClient

tests/unit_tests/conftest.py

@@ -1,64 +0,0 @@
-import pytest
-from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
-from qtpy.QtWidgets import QApplication
-
-from bec_widgets.cli.rpc_register import RPCRegister
-from bec_widgets.qt_utils import error_popups
-from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
-
-
-@pytest.fixture(autouse=True)
-def qapplication(qtbot):  # pylint: disable=unused-argument
-    yield
-
-    qapp = QApplication.instance()
-    # qapp.quit()
-    qapp.processEvents()
-    try:
-        qtbot.waitUntil(lambda: qapp.topLevelWidgets() == [])
-    except QtBotTimeoutError as exc:
-        raise TimeoutError(f"Failed to close all widgets: {qapp.topLevelWidgets()}") from exc
-
-
-@pytest.fixture(autouse=True)
-def rpc_register():
-    yield RPCRegister()
-    RPCRegister.reset_singleton()
-
-
-@pytest.fixture(autouse=True)
-def bec_dispatcher(threads_check):  # pylint: disable=unused-argument
-    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
-    yield bec_dispatcher
-    bec_dispatcher.disconnect_all()
-    # clean BEC client
-    bec_dispatcher.client.shutdown()
-    # reinitialize singleton for next test
-    bec_dispatcher_module.BECDispatcher.reset_singleton()
-
-
-@pytest.fixture(autouse=True)
-def clean_singleton():
-    error_popups._popup_utility_instance = None
-
-
-def create_widget(qtbot, widget, *args, **kwargs):
-    """
-    Create a widget and add it to the qtbot for testing. This is a helper function that
-    should be used in all tests that require a widget to be created.
-    DO NOT CREATE WIDGETS DIRECTLY IN A FIXTURE!
-
-    Args:
-        qtbot (fixture): pytest-qt fixture
-        widget (QWidget): widget class to be created
-        *args: positional arguments for the widget
-        **kwargs: keyword arguments for the widget
-
-    Returns:
-        QWidget: the created widget
-
-    """
-    widget = widget(*args, **kwargs)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    return widget

tests/unit_tests/test_bec_connector.py

@@ -1,80 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-import time
-
-import pytest
-from qtpy.QtWidgets import QApplication
-
-from bec_widgets.qt_utils.error_popups import SafeSlot as Slot
-from bec_widgets.utils import BECConnector, ConnectionConfig
-
-from .client_mocks import mocked_client
-
-
-@pytest.fixture
-def bec_connector(mocked_client):
-    connector = BECConnector(client=mocked_client)
-    return connector
-
-
-def test_bec_connector_init(bec_connector):
-    assert bec_connector is not None
-    assert bec_connector.client is not None
-    assert isinstance(bec_connector, BECConnector)
-    assert bec_connector.config.widget_class == "BECConnector"
-
-
-def test_bec_connector_init_with_gui_id(mocked_client):
-    bc = BECConnector(client=mocked_client, gui_id="test_gui_id")
-    assert bc.config.gui_id == "test_gui_id"
-    assert bc.gui_id == "test_gui_id"
-
-
-def test_bec_connector_set_gui_id(bec_connector):
-    bec_connector.set_gui_id("test_gui_id")
-    assert bec_connector.config.gui_id == "test_gui_id"
-
-
-def test_bec_connector_change_config(bec_connector):
-    bec_connector.on_config_update({"gui_id": "test_gui_id"})
-    assert bec_connector.config.gui_id == "test_gui_id"
-
-
-def test_bec_connector_get_obj_by_id(bec_connector):
-    bec_connector.set_gui_id("test_gui_id")
-    assert bec_connector.get_obj_by_id("test_gui_id") == bec_connector
-    assert bec_connector.get_obj_by_id("test_gui_id_2") is None
-
-
-def test_bec_connector_update_client(bec_connector, mocked_client):
-    client_new = mocked_client
-    bec_connector.update_client(client_new)
-    assert bec_connector.client == client_new
-    assert bec_connector.dev is not None
-    assert bec_connector.scans is not None
-    assert bec_connector.queue is not None
-    assert bec_connector.scan_storage is not None
-    assert bec_connector.dap is not None
-
-
-def test_bec_connector_get_config(bec_connector):
-    assert bec_connector.get_config(dict_output=False) == bec_connector.config
-    assert bec_connector.get_config() == bec_connector.config.model_dump()
-
-
-def test_bec_connector_submit_task(bec_connector):
-    def test_func():
-        time.sleep(2)
-        print("done")
-
-    completed = False
-
-    @Slot()
-    def complete_func():
-        nonlocal completed
-        completed = True
-
-    bec_connector.submit_task(test_func, on_complete=complete_func)
-    assert not completed
-    while not completed:
-        QApplication.processEvents()
-        time.sleep(0.1)

tests/unit_tests/test_bec_dispatcher.py

@@ -1,119 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-import threading
-import time
-from unittest import mock
-
-import pytest
-import redis
-from bec_lib.connector import MessageObject
-from bec_lib.messages import ScanMessage
-from bec_lib.redis_connector import RedisConnector
-from bec_lib.serialization import MsgpackSerialization
-
-from bec_widgets.utils.bec_dispatcher import QtRedisConnector
-
-
-@pytest.fixture
-def bec_dispatcher_w_connector(bec_dispatcher, topics_msg_list, send_msg_event):
-    def pubsub_msg_generator():
-        send_msg_event.wait()
-        for topic, msg in topics_msg_list:
-            yield {"channel": topic.encode(), "pattern": None, "data": msg}
-        while True:
-            time.sleep(0.2)
-            yield StopIteration
-
-    with mock.patch("redis.Redis"):
-        pubsub = redis.Redis().pubsub()
-        messages = pubsub_msg_generator()
-        pubsub.get_message.side_effect = lambda timeout: next(messages)
-        connector = QtRedisConnector("localhost:1")
-        bec_dispatcher.client.connector = connector
-        yield bec_dispatcher
-
-
-dummy_msg = MsgpackSerialization.dumps(ScanMessage(point_id=0, scan_id="0", data={}))
-
-
-@pytest.fixture
-def send_msg_event():
-    return threading.Event()
-
-
-@pytest.mark.parametrize(
-    "topics_msg_list", [(("topic1", dummy_msg), ("topic2", dummy_msg), ("topic3", dummy_msg))]
-)
-def test_dispatcher_disconnect_all(bec_dispatcher_w_connector, qtbot, send_msg_event):
-    bec_dispatcher = bec_dispatcher_w_connector
-    cb1 = mock.Mock(spec=[])
-    cb2 = mock.Mock(spec=[])
-
-    bec_dispatcher.connect_slot(cb1, "topic1")
-    bec_dispatcher.connect_slot(cb1, "topic2")
-    bec_dispatcher.connect_slot(cb2, "topic2")
-    bec_dispatcher.connect_slot(cb2, "topic3")
-    assert len(bec_dispatcher.client.connector._topics_cb) == 3
-    send_msg_event.set()
-    qtbot.wait(10)
-    assert cb1.call_count == 2
-    assert cb2.call_count == 2
-
-    bec_dispatcher.disconnect_all()
-
-    assert len(bec_dispatcher.client.connector._topics_cb) == 0
-
-
-@pytest.mark.parametrize("topics_msg_list", [(("topic1", dummy_msg), ("topic2", dummy_msg))])
-def test_dispatcher_disconnect_one(bec_dispatcher_w_connector, qtbot, send_msg_event):
-    # test for BEC issue #276
-    bec_dispatcher = bec_dispatcher_w_connector
-    cb1 = mock.Mock(spec=[])
-    cb2 = mock.Mock(spec=[])
-
-    bec_dispatcher.connect_slot(cb1, "topic1")
-    bec_dispatcher.connect_slot(cb2, "topic2")
-    assert len(bec_dispatcher.client.connector._topics_cb) == 2
-    bec_dispatcher.disconnect_slot(cb1, "topic1")
-    assert len(bec_dispatcher.client.connector._topics_cb) == 1
-
-    send_msg_event.set()
-    qtbot.wait(10)
-    assert cb1.call_count == 0
-    cb2.assert_called_once()
-
-
-@pytest.mark.parametrize("topics_msg_list", [(("topic1", dummy_msg),)])
-def test_dispatcher_2_cb_same_topic(bec_dispatcher_w_connector, qtbot, send_msg_event):
-    # test for BEC issue #276
-    bec_dispatcher = bec_dispatcher_w_connector
-    cb1 = mock.Mock(spec=[])
-    cb2 = mock.Mock(spec=[])
-
-    bec_dispatcher.connect_slot(cb1, "topic1")
-    bec_dispatcher.connect_slot(cb2, "topic1")
-    assert len(bec_dispatcher.client.connector._topics_cb) == 1
-    assert len(bec_dispatcher._slots) == 2
-    bec_dispatcher.disconnect_slot(cb1, "topic1")
-    assert len(bec_dispatcher._slots) == 1
-
-    send_msg_event.set()
-    qtbot.wait(10)
-    assert cb1.call_count == 0
-    cb2.assert_called_once()
-
-
-@pytest.mark.parametrize("topics_msg_list", [(("topic1", dummy_msg), ("topic2", dummy_msg))])
-def test_dispatcher_2_topic_same_cb(bec_dispatcher_w_connector, qtbot, send_msg_event):
-    # test for BEC issue #276
-    bec_dispatcher = bec_dispatcher_w_connector
-    cb1 = mock.Mock(spec=[])
-
-    bec_dispatcher.connect_slot(cb1, "topic1")
-    bec_dispatcher.connect_slot(cb1, "topic2")
-    assert len(bec_dispatcher.client.connector._topics_cb) == 2
-    bec_dispatcher.disconnect_slot(cb1, "topic1")
-    assert len(bec_dispatcher.client.connector._topics_cb) == 1
-
-    send_msg_event.set()
-    qtbot.wait(10)
-    cb1.assert_called_once()

tests/unit_tests/test_bec_dock.py

@@ -1,155 +0,0 @@
-# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from bec_widgets.widgets.dock import BECDock, BECDockArea
-
-from .client_mocks import mocked_client
-
-
-@pytest.fixture
-def bec_dock_area(qtbot, mocked_client):
-    widget = BECDockArea(client=mocked_client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_bec_dock_area_init(bec_dock_area):
-    assert bec_dock_area is not None
-    assert bec_dock_area.client is not None
-    assert isinstance(bec_dock_area, BECDockArea)
-    assert bec_dock_area.config.widget_class == "BECDockArea"
-
-
-def test_bec_dock_area_add_remove_dock(bec_dock_area, qtbot):
-    initial_count = len(bec_dock_area.dock_area.docks)
-
-    # Adding 3 docks
-    d0 = bec_dock_area.add_dock()
-    d1 = bec_dock_area.add_dock()
-    d2 = bec_dock_area.add_dock()
-
-    # Check if the docks were added
-    assert len(bec_dock_area.dock_area.docks) == initial_count + 3
-    assert d0.name() in dict(bec_dock_area.dock_area.docks)
-    assert d1.name() in dict(bec_dock_area.dock_area.docks)
-    assert d2.name() in dict(bec_dock_area.dock_area.docks)
-    assert bec_dock_area.dock_area.docks[d0.name()].config.widget_class == "BECDock"
-    assert bec_dock_area.dock_area.docks[d1.name()].config.widget_class == "BECDock"
-    assert bec_dock_area.dock_area.docks[d2.name()].config.widget_class == "BECDock"
-
-    # Check panels API for getting docks to CLI
-    assert bec_dock_area.panels == dict(bec_dock_area.dock_area.docks)
-
-    # Remove docks
-    d0_name = d0.name()
-    bec_dock_area.remove_dock(d0_name)
-    qtbot.wait(200)
-    d1.remove()
-    qtbot.wait(200)
-
-    assert len(bec_dock_area.dock_area.docks) == initial_count + 1
-    assert d0.name() not in dict(bec_dock_area.dock_area.docks)
-    assert d1.name() not in dict(bec_dock_area.dock_area.docks)
-    assert d2.name() in dict(bec_dock_area.dock_area.docks)
-
-
-def test_add_remove_bec_figure_to_dock(bec_dock_area):
-    d0 = bec_dock_area.add_dock()
-    fig = d0.add_widget("BECFigure")
-    plt = fig.plot(x_name="samx", y_name="bpm4i")
-    im = fig.image("eiger")
-    mm = fig.motor_map("samx", "samy")
-
-    assert len(bec_dock_area.dock_area.docks) == 1
-    assert len(d0.widgets) == 1
-    assert len(d0.widget_list) == 1
-    assert len(fig.widgets) == 3
-
-    assert fig.config.widget_class == "BECFigure"
-    assert plt.config.widget_class == "BECWaveform"
-    assert im.config.widget_class == "BECImageShow"
-    assert mm.config.widget_class == "BECMotorMap"
-
-
-def test_close_docks(bec_dock_area, qtbot):
-    d0 = bec_dock_area.add_dock(name="dock_0")
-    d1 = bec_dock_area.add_dock(name="dock_1")
-    d2 = bec_dock_area.add_dock(name="dock_2")
-
-    bec_dock_area.clear_all()
-    qtbot.wait(200)
-    assert len(bec_dock_area.dock_area.docks) == 0
-
-
-def test_undock_and_dock_docks(bec_dock_area, qtbot):
-    d0 = bec_dock_area.add_dock(name="dock_0")
-    d1 = bec_dock_area.add_dock(name="dock_1")
-    d2 = bec_dock_area.add_dock(name="dock_4")
-    d3 = bec_dock_area.add_dock(name="dock_3")
-
-    d0.detach()
-    bec_dock_area.detach_dock("dock_1")
-    d2.detach()
-
-    assert len(bec_dock_area.dock_area.docks) == 4
-    assert len(bec_dock_area.dock_area.tempAreas) == 3
-
-    d0.attach()
-    assert len(bec_dock_area.dock_area.docks) == 4
-    assert len(bec_dock_area.dock_area.tempAreas) == 2
-
-    bec_dock_area.attach_all()
-    assert len(bec_dock_area.dock_area.docks) == 4
-    assert len(bec_dock_area.dock_area.tempAreas) == 0
-
-
-###################################
-# Toolbar Actions
-###################################
-def test_toolbar_add_plot_waveform(bec_dock_area):
-    bec_dock_area.toolbar.widgets["menu_plots"].widgets["waveform"].trigger()
-    assert "waveform_1" in bec_dock_area.panels
-    assert bec_dock_area.panels["waveform_1"].widgets[0].config.widget_class == "BECWaveformWidget"
-
-
-def test_toolbar_add_plot_image(bec_dock_area):
-    bec_dock_area.toolbar.widgets["menu_plots"].widgets["image"].trigger()
-    assert "image_1" in bec_dock_area.panels
-    assert bec_dock_area.panels["image_1"].widgets[0].config.widget_class == "BECImageWidget"
-
-
-def test_toolbar_add_plot_motor_map(bec_dock_area):
-    bec_dock_area.toolbar.widgets["menu_plots"].widgets["motor_map"].trigger()
-    assert "motor_map_1" in bec_dock_area.panels
-    assert bec_dock_area.panels["motor_map_1"].widgets[0].config.widget_class == "BECMotorMapWidget"
-
-
-def test_toolbar_add_device_positioner_box(bec_dock_area):
-    bec_dock_area.toolbar.widgets["menu_devices"].widgets["positioner_box"].trigger()
-    assert "positioner_box_1" in bec_dock_area.panels
-    assert (
-        bec_dock_area.panels["positioner_box_1"].widgets[0].config.widget_class == "PositionerBox"
-    )
-
-
-def test_toolbar_add_utils_queue(bec_dock_area):
-    bec_dock_area.toolbar.widgets["menu_utils"].widgets["queue"].trigger()
-    assert "queue_1" in bec_dock_area.panels
-    assert bec_dock_area.panels["queue_1"].widgets[0].config.widget_class == "BECQueue"
-
-
-def test_toolbar_add_utils_status(bec_dock_area):
-    bec_dock_area.toolbar.widgets["menu_utils"].widgets["status"].trigger()
-    assert "status_1" in bec_dock_area.panels
-    assert bec_dock_area.panels["status_1"].widgets[0].config.widget_class == "BECStatusBox"
-
-
-def test_toolbar_add_utils_progress_bar(bec_dock_area):
-    bec_dock_area.toolbar.widgets["menu_utils"].widgets["progress_bar"].trigger()
-    assert "progress_bar_1" in bec_dock_area.panels
-    assert (
-        bec_dock_area.panels["progress_bar_1"].widgets[0].config.widget_class == "RingProgressBar"
-    )