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

tests/end-2-end/conftest.py

@@ -1,53 +0,0 @@
-import random
-import time
-from contextlib import contextmanager
-
-import pytest
-from bec_lib.endpoints import MessageEndpoints
-
-from bec_widgets.cli.client_utils import _start_plot_process
-from bec_widgets.cli.rpc_register import RPCRegister
-from bec_widgets.utils import BECDispatcher
-from bec_widgets.widgets.dock import BECDockArea
-from bec_widgets.widgets.figure import BECFigure
-
-
-# make threads check in autouse, **will be executed at the end**; better than
-# having it in fixtures for each test, since it prevents from needing to
-# 'manually' shutdown bec_client_lib (for example) to make it happy, whereas
-# whereas in fact bec_client_lib makes its on cleanup
-@pytest.fixture(autouse=True)
-def threads_check_fixture(threads_check):
-    return
-
-
-@pytest.fixture
-def gui_id():
-    return f"figure_{random.randint(0,100)}"  # make a new gui id each time, to ensure no 'gui is alive' zombie key can perturbate
-
-
-@contextmanager
-def plot_server(gui_id, klass, client_lib):
-    dispatcher = BECDispatcher(client=client_lib)  # Has to init singleton with fixture client
-    process, _ = _start_plot_process(gui_id, klass, client_lib._client._service_config.config_path)
-    try:
-        while client_lib._client.connector.get(MessageEndpoints.gui_heartbeat(gui_id)) is None:
-            time.sleep(0.3)
-        yield gui_id
-    finally:
-        process.terminate()
-        process.wait()
-        dispatcher.disconnect_all()
-        dispatcher.reset_singleton()
-
-
-@pytest.fixture
-def rpc_server_figure(gui_id, bec_client_lib):
-    with plot_server(gui_id, BECFigure, bec_client_lib) as server:
-        yield server
-
-
-@pytest.fixture
-def rpc_server_dock(gui_id, bec_client_lib):
-    with plot_server(gui_id, BECDockArea, bec_client_lib) as server:
-        yield server

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -1,298 +0,0 @@
-import time
-
-import numpy as np
-import pytest
-from bec_lib.client import BECClient
-from bec_lib.endpoints import MessageEndpoints
-
-from bec_widgets.cli.auto_updates import AutoUpdates
-from bec_widgets.cli.client import BECDockArea, BECFigure, BECImageShow, BECMotorMap, BECWaveform
-from bec_widgets.utils import Colors
-
-# pylint: disable=unused-argument
-# pylint: disable=redefined-outer-name
-# pylint: disable=too-many-locals
-
-
-def test_rpc_add_dock_with_figure_e2e(bec_client_lib, rpc_server_dock):
-    # BEC client shortcuts
-    dock = BECDockArea(rpc_server_dock)
-    client = bec_client_lib
-    dev = client.device_manager.devices
-    scans = client.scans
-    queue = client.queue
-
-    # Create 3 docks
-    d0 = dock.add_dock("dock_0")
-    d1 = dock.add_dock("dock_1")
-    d2 = dock.add_dock("dock_2")
-
-    dock_config = dock._config_dict
-    assert len(dock_config["docks"]) == 3
-    # Add 3 figures with some widgets
-    fig0 = d0.add_widget("BECFigure")
-    fig1 = d1.add_widget("BECFigure")
-    fig2 = d2.add_widget("BECFigure")
-
-    dock_config = dock._config_dict
-    assert len(dock_config["docks"]) == 3
-    assert len(dock_config["docks"]["dock_0"]["widgets"]) == 1
-    assert len(dock_config["docks"]["dock_1"]["widgets"]) == 1
-    assert len(dock_config["docks"]["dock_2"]["widgets"]) == 1
-
-    assert fig1.__class__.__name__ == "BECFigure"
-    assert fig1.__class__ == BECFigure
-    assert fig2.__class__.__name__ == "BECFigure"
-    assert fig2.__class__ == BECFigure
-
-    mm = fig0.motor_map("samx", "samy")
-    plt = fig1.plot(x_name="samx", y_name="bpm4i")
-    im = fig2.image("eiger")
-
-    assert mm.__class__.__name__ == "BECMotorMap"
-    assert mm.__class__ == BECMotorMap
-    assert plt.__class__.__name__ == "BECWaveform"
-    assert plt.__class__ == BECWaveform
-    assert im.__class__.__name__ == "BECImageShow"
-    assert im.__class__ == BECImageShow
-
-    assert mm._config_dict["signals"] == {
-        "dap": None,
-        "source": "device_readback",
-        "x": {
-            "name": "samx",
-            "entry": "samx",
-            "unit": None,
-            "modifier": None,
-            "limits": [-50.0, 50.0],
-        },
-        "y": {
-            "name": "samy",
-            "entry": "samy",
-            "unit": None,
-            "modifier": None,
-            "limits": [-50.0, 50.0],
-        },
-        "z": None,
-    }
-    assert plt._config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
-        "dap": None,
-        "source": "scan_segment",
-        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
-        "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
-        "z": None,
-    }
-    assert im._config_dict["images"]["eiger"]["monitor"] == "eiger"
-
-    # check initial position of motor map
-    initial_pos_x = dev.samx.read()["samx"]["value"]
-    initial_pos_y = dev.samy.read()["samy"]["value"]
-
-    # Try to make a scan
-    status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
-
-    # wait for scan to finish
-    while not status.status == "COMPLETED":
-        time.sleep(0.2)
-
-    # plot
-    plt_last_scan_data = queue.scan_storage.storage[-1].data
-    plt_data = plt.get_all_data()
-    assert plt_data["bpm4i-bpm4i"]["x"] == plt_last_scan_data["samx"]["samx"].val
-    assert plt_data["bpm4i-bpm4i"]["y"] == plt_last_scan_data["bpm4i"]["bpm4i"].val
-
-    # image
-    last_image_device = client.connector.get_last(MessageEndpoints.device_monitor_2d("eiger"))[
-        "data"
-    ].data
-    time.sleep(0.5)
-    last_image_plot = im.images[0].get_data()
-    np.testing.assert_equal(last_image_device, last_image_plot)
-
-    # motor map
-    final_pos_x = dev.samx.read()["samx"]["value"]
-    final_pos_y = dev.samy.read()["samy"]["value"]
-
-    # check final coordinates of motor map
-    motor_map_data = mm.get_data()
-
-    np.testing.assert_equal(
-        [motor_map_data["x"][0], motor_map_data["y"][0]], [initial_pos_x, initial_pos_y]
-    )
-    np.testing.assert_equal(
-        [motor_map_data["x"][-1], motor_map_data["y"][-1]], [final_pos_x, final_pos_y]
-    )
-
-
-def test_dock_manipulations_e2e(rpc_server_dock):
-    dock = BECDockArea(rpc_server_dock)
-
-    d0 = dock.add_dock("dock_0")
-    d1 = dock.add_dock("dock_1")
-    d2 = dock.add_dock("dock_2")
-    dock_config = dock._config_dict
-    assert len(dock_config["docks"]) == 3
-
-    d0.detach()
-    dock.detach_dock("dock_2")
-    dock_config = dock._config_dict
-    assert len(dock_config["docks"]) == 3
-    assert len(dock.temp_areas) == 2
-
-    d0.attach()
-    dock_config = dock._config_dict
-    assert len(dock_config["docks"]) == 3
-    assert len(dock.temp_areas) == 1
-
-    d2.remove()
-    dock_config = dock._config_dict
-    assert len(dock_config["docks"]) == 2
-
-    assert ["dock_0", "dock_1"] == list(dock_config["docks"])
-
-    dock.clear_all()
-
-    dock_config = dock._config_dict
-    assert len(dock_config["docks"]) == 0
-    assert len(dock.temp_areas) == 0
-
-
-def test_ring_bar(rpc_server_dock):
-    dock = BECDockArea(rpc_server_dock)
-
-    d0 = dock.add_dock(name="dock_0")
-
-    bar = d0.add_widget("RingProgressBar")
-    assert bar.__class__.__name__ == "RingProgressBar"
-
-    bar.set_number_of_bars(5)
-    bar.set_colors_from_map("viridis")
-    bar.set_value([10, 20, 30, 40, 50])
-
-    bar_config = bar._config_dict
-
-    expected_colors = [list(color) for color in Colors.golden_angle_color("viridis", 5, "RGB")]
-    bar_colors = [ring._config_dict["color"] for ring in bar.rings]
-    bar_values = [ring._config_dict["value"] for ring in bar.rings]
-    assert bar_config["num_bars"] == 5
-    assert bar_values == [10, 20, 30, 40, 50]
-    assert bar_colors == expected_colors
-
-
-def test_ring_bar_scan_update(bec_client_lib, rpc_server_dock):
-    dock = BECDockArea(rpc_server_dock)
-
-    d0 = dock.add_dock("dock_0")
-
-    bar = d0.add_widget("RingProgressBar")
-
-    client = bec_client_lib
-    dev = client.device_manager.devices
-    dev.samx.tolerance.set(0)
-    dev.samy.tolerance.set(0)
-    scans = client.scans
-
-    status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
-    status.wait()
-
-    bar_config = bar._config_dict
-    assert bar_config["num_bars"] == 1
-    assert bar_config["rings"][0]["value"] == 10
-    assert bar_config["rings"][0]["min_value"] == 0
-    assert bar_config["rings"][0]["max_value"] == 10
-
-    status = scans.grid_scan(dev.samx, -5, 5, 4, dev.samy, -10, 10, 4, relative=True, exp_time=0.1)
-    status.wait()
-
-    bar_config = bar._config_dict
-    assert bar_config["num_bars"] == 1
-    assert bar_config["rings"][0]["value"] == 16
-    assert bar_config["rings"][0]["min_value"] == 0
-    assert bar_config["rings"][0]["max_value"] == 16
-
-    init_samx = dev.samx.read()["samx"]["value"]
-    init_samy = dev.samy.read()["samy"]["value"]
-    final_samx = init_samx + 5
-    final_samy = init_samy + 10
-
-    dev.samx.velocity.put(5)
-    dev.samy.velocity.put(5)
-
-    status = scans.umv(dev.samx, 5, dev.samy, 10, relative=True)
-    status.wait()
-
-    bar_config = bar._config_dict
-    assert bar_config["num_bars"] == 2
-    assert bar_config["rings"][0]["value"] == final_samx
-    assert bar_config["rings"][1]["value"] == final_samy
-    assert bar_config["rings"][0]["min_value"] == init_samx
-    assert bar_config["rings"][0]["max_value"] == final_samx
-    assert bar_config["rings"][1]["min_value"] == init_samy
-    assert bar_config["rings"][1]["max_value"] == final_samy
-
-
-def test_auto_update(bec_client_lib, rpc_server_dock, qtbot):
-    dock = BECDockArea(rpc_server_dock)
-
-    AutoUpdates.enabled = True
-    AutoUpdates.create_default_dock = True
-    dock.auto_updates = AutoUpdates(gui=dock)
-    dock.auto_updates.start_default_dock()
-
-    def get_default_figure():
-        return dock.auto_updates.get_default_figure()
-
-    qtbot.waitUntil(lambda: get_default_figure() is not None, timeout=10000)
-    plt = get_default_figure()
-
-    dock.selected_device = "bpm4i"
-
-    # we need to start the update script manually; normally this is done when the GUI is started
-    dock._start_update_script()
-
-    client = bec_client_lib
-    dev = client.device_manager.devices
-    scans = client.scans
-    queue = client.queue
-
-    status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
-    status.wait()
-
-    last_scan_data = queue.scan_storage.storage[-1].data
-
-    # get data from curves
-    widgets = plt.widget_list
-    plt_data = widgets[0].get_all_data()
-
-    # check plotted data
-    assert (
-        plt_data[f"Scan {status.scan.scan_number} - bpm4i"]["x"]
-        == last_scan_data["samx"]["samx"].val
-    )
-    assert (
-        plt_data[f"Scan {status.scan.scan_number} - bpm4i"]["y"]
-        == last_scan_data["bpm4i"]["bpm4i"].val
-    )
-
-    status = scans.grid_scan(
-        dev.samx, -10, 10, 5, dev.samy, -5, 5, 5, exp_time=0.05, relative=False
-    )
-    status.wait()
-
-    plt = dock.auto_updates.get_default_figure()
-    widgets = plt.widget_list
-    qtbot.waitUntil(lambda: len(plt.widget_list) > 0, timeout=5000)
-    plt_data = widgets[0].get_all_data()
-
-    last_scan_data = queue.scan_storage.storage[-1].data
-
-    # check plotted data
-    assert (
-        plt_data[f"Scan {status.scan.scan_number} - {dock.selected_device}"]["x"]
-        == last_scan_data["samx"]["samx"].val
-    )
-    assert (
-        plt_data[f"Scan {status.scan.scan_number} - {dock.selected_device}"]["y"]
-        == last_scan_data["samy"]["samy"].val
-    )
-    dock.auto_updates.shutdown()

tests/end-2-end/test_bec_figure_rpc_e2e.py

@@ -1,212 +0,0 @@
-import time
-
-import numpy as np
-import pytest
-from bec_lib.endpoints import MessageEndpoints
-
-from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
-
-
-def test_rpc_waveform1d_custom_curve(rpc_server_figure):
-    fig = BECFigure(rpc_server_figure)
-
-    ax = fig.plot()
-    curve = ax.plot(x=[1, 2, 3], y=[1, 2, 3])
-    curve.set_color("red")
-    curve = ax.curves[0]
-    curve.set_color("blue")
-
-    assert len(fig.widgets) == 1
-    assert len(fig.widgets[ax._rpc_id].curves) == 1
-
-
-def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
-    fig = BECFigure(rpc_server_figure)
-
-    plt = fig.plot(x_name="samx", y_name="bpm4i")
-    im = fig.image("eiger")
-    motor_map = fig.motor_map("samx", "samy")
-    plt_z = fig.plot(x_name="samx", y_name="samy", z_name="bpm4i", new=True)
-
-    # Checking if classes are correctly initialised
-    assert len(fig.widgets) == 4
-    assert plt.__class__.__name__ == "BECWaveform"
-    assert plt.__class__ == BECWaveform
-    assert im.__class__.__name__ == "BECImageShow"
-    assert im.__class__ == BECImageShow
-    assert motor_map.__class__.__name__ == "BECMotorMap"
-    assert motor_map.__class__ == BECMotorMap
-
-    # check if the correct devices are set
-    # plot
-    assert plt._config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
-        "dap": None,
-        "source": "scan_segment",
-        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
-        "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
-        "z": None,
-    }
-    # image
-    assert im._config_dict["images"]["eiger"]["monitor"] == "eiger"
-    # motor map
-    assert motor_map._config_dict["signals"] == {
-        "dap": None,
-        "source": "device_readback",
-        "x": {
-            "name": "samx",
-            "entry": "samx",
-            "unit": None,
-            "modifier": None,
-            "limits": [-50.0, 50.0],
-        },
-        "y": {
-            "name": "samy",
-            "entry": "samy",
-            "unit": None,
-            "modifier": None,
-            "limits": [-50.0, 50.0],
-        },
-        "z": None,
-    }
-    # plot with z scatter
-    assert plt_z._config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
-        "dap": None,
-        "source": "scan_segment",
-        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
-        "y": {"name": "samy", "entry": "samy", "unit": None, "modifier": None, "limits": None},
-        "z": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
-    }
-
-
-def test_rpc_waveform_scan(rpc_server_figure, bec_client_lib):
-    fig = BECFigure(rpc_server_figure)
-
-    # add 3 different curves to track
-    plt = fig.plot(x_name="samx", y_name="bpm4i")
-    fig.plot(x_name="samx", y_name="bpm3a")
-    fig.plot(x_name="samx", y_name="bpm4d")
-
-    client = bec_client_lib
-    dev = client.device_manager.devices
-    scans = client.scans
-    queue = client.queue
-
-    status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
-    status.wait()
-
-    last_scan_data = queue.scan_storage.storage[-1].data
-
-    # get data from curves
-    plt_data = plt.get_all_data()
-
-    # check plotted data
-    assert plt_data["bpm4i-bpm4i"]["x"] == last_scan_data["samx"]["samx"].val
-    assert plt_data["bpm4i-bpm4i"]["y"] == last_scan_data["bpm4i"]["bpm4i"].val
-    assert plt_data["bpm3a-bpm3a"]["x"] == last_scan_data["samx"]["samx"].val
-    assert plt_data["bpm3a-bpm3a"]["y"] == last_scan_data["bpm3a"]["bpm3a"].val
-    assert plt_data["bpm4d-bpm4d"]["x"] == last_scan_data["samx"]["samx"].val
-    assert plt_data["bpm4d-bpm4d"]["y"] == last_scan_data["bpm4d"]["bpm4d"].val
-
-
-def test_rpc_image(rpc_server_figure, bec_client_lib):
-    fig = BECFigure(rpc_server_figure)
-
-    im = fig.image("eiger")
-
-    client = bec_client_lib
-    dev = client.device_manager.devices
-    scans = client.scans
-
-    status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
-    status.wait()
-
-    last_image_device = client.connector.get_last(MessageEndpoints.device_monitor_2d("eiger"))[
-        "data"
-    ].data
-    last_image_plot = im.images[0].get_data()
-
-    # check plotted data
-    np.testing.assert_equal(last_image_device, last_image_plot)
-
-
-def test_rpc_motor_map(rpc_server_figure, bec_client_lib):
-    fig = BECFigure(rpc_server_figure)
-
-    motor_map = fig.motor_map("samx", "samy")
-
-    client = bec_client_lib
-    dev = client.device_manager.devices
-    scans = client.scans
-
-    initial_pos_x = dev.samx.read()["samx"]["value"]
-    initial_pos_y = dev.samy.read()["samy"]["value"]
-
-    status = scans.mv(dev.samx, 1, dev.samy, 2, relative=True)
-    status.wait()
-
-    final_pos_x = dev.samx.read()["samx"]["value"]
-    final_pos_y = dev.samy.read()["samy"]["value"]
-
-    # check plotted data
-    motor_map_data = motor_map.get_data()
-
-    np.testing.assert_equal(
-        [motor_map_data["x"][0], motor_map_data["y"][0]], [initial_pos_x, initial_pos_y]
-    )
-    np.testing.assert_equal(
-        [motor_map_data["x"][-1], motor_map_data["y"][-1]], [final_pos_x, final_pos_y]
-    )
-
-
-def test_dap_rpc(rpc_server_figure, bec_client_lib, qtbot):
-
-    fig = BECFigure(rpc_server_figure)
-    plt = fig.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
-
-    client = bec_client_lib
-    dev = client.device_manager.devices
-    scans = client.scans
-
-    dev.bpm4i.sim.sim_select_model("GaussianModel")
-    params = dev.bpm4i.sim.sim_params
-    params.update(
-        {"noise": "uniform", "noise_multiplier": 10, "center": 5, "sigma": 1, "amplitude": 200}
-    )
-    dev.bpm4i.sim.sim_params = params
-    time.sleep(1)
-
-    res = scans.line_scan(dev.samx, 0, 8, steps=50, relative=False)
-    res.wait()
-
-    # especially on slow machines, the fit might not be done yet
-    # so we wait until the fit reaches the expected value
-    def wait_for_fit():
-        dap_curve = plt.get_curve("bpm4i-bpm4i-GaussianModel")
-        fit_params = dap_curve.dap_params
-        print(fit_params)
-        return np.isclose(fit_params["center"], 5, atol=0.5)
-
-    qtbot.waitUntil(wait_for_fit, timeout=10000)
-
-
-def test_removing_subplots(rpc_server_figure, bec_client_lib):
-    fig = BECFigure(rpc_server_figure)
-    plt = fig.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
-    im = fig.image(monitor="eiger")
-    mm = fig.motor_map(motor_x="samx", motor_y="samy")
-
-    assert len(fig.widget_list) == 3
-
-    # removing curves
-    assert len(plt.curves) == 2
-    plt.curves[0].remove()
-    assert len(plt.curves) == 1
-    plt.remove_curve("bpm4i-bpm4i")
-    assert len(plt.curves) == 0
-
-    # removing all subplots from figure
-    plt.remove()
-    im.remove()
-    mm.remove()
-
-    assert len(fig.widget_list) == 0

tests/end-2-end/test_rpc_register_e2e.py

@@ -1,40 +0,0 @@
-import pytest
-
-from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
-
-
-def test_rpc_register_list_connections(rpc_server_figure):
-    fig = BECFigure(rpc_server_figure)
-
-    plt = fig.plot(x_name="samx", y_name="bpm4i")
-    im = fig.image("eiger")
-    motor_map = fig.motor_map("samx", "samy")
-    plt_z = fig.plot(x_name="samx", y_name="samy", z_name="bpm4i", new=True)
-
-    # keep only class names from objects, since objects on server and client are different
-    # so the best we can do is to compare types (rpc register is unit-tested elsewhere)
-    all_connections = {obj_id: type(obj).__name__ for obj_id, obj in fig._get_all_rpc().items()}
-
-    all_subwidgets_expected = {wid: type(widget).__name__ for wid, widget in fig.widgets.items()}
-    curve_1D = fig.widgets[plt._rpc_id]
-    curve_2D = fig.widgets[plt_z._rpc_id]
-    curves_expected = {
-        curve_1D._rpc_id: type(curve_1D).__name__,
-        curve_2D._rpc_id: type(curve_2D).__name__,
-    }
-    curves_expected.update({curve._gui_id: type(curve).__name__ for curve in curve_1D.curves})
-    curves_expected.update({curve._gui_id: type(curve).__name__ for curve in curve_2D.curves})
-    fig_expected = {fig._rpc_id: type(fig).__name__}
-    image_item_expected = {
-        fig.widgets[im._rpc_id].images[0]._rpc_id: type(fig.widgets[im._rpc_id].images[0]).__name__
-    }
-
-    all_connections_expected = {
-        **all_subwidgets_expected,
-        **curves_expected,
-        **fig_expected,
-        **image_item_expected,
-    }
-
-    assert len(all_connections) == 8
-    assert all_connections == all_connections_expected

tests/end-2-end/test_scan_control_e2e.py

@@ -1,71 +0,0 @@
-import time
-
-import pytest
-
-from bec_widgets.utils.widget_io import WidgetIO
-from bec_widgets.widgets.scan_control import ScanControl
-
-
-@pytest.fixture(scope="function")
-def scan_control(qtbot, bec_client_lib):  # , mock_dev):
-    widget = ScanControl(client=bec_client_lib)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_scan_control_populate_scans_e2e(scan_control):
-    expected_scans = [
-        "grid_scan",
-        "fermat_scan",
-        "round_scan",
-        "cont_line_scan",
-        "cont_line_fly_scan",
-        "round_scan_fly",
-        "round_roi_scan",
-        "time_scan",
-        "monitor_scan",
-        "acquire",
-        "line_scan",
-    ]
-    items = [
-        scan_control.comboBox_scan_selection.itemText(i)
-        for i in range(scan_control.comboBox_scan_selection.count())
-    ]
-    assert scan_control.comboBox_scan_selection.count() == len(expected_scans)
-    assert sorted(items) == sorted(expected_scans)
-
-
-def test_run_line_scan_with_parameters_e2e(scan_control, bec_client_lib, qtbot):
-    client = bec_client_lib
-    queue = client.queue
-
-    scan_name = "line_scan"
-    kwargs = {"exp_time": 0.01, "steps": 10, "relative": True, "burst_at_each_point": 1}
-    args = {"device": "samx", "start": -5, "stop": 5}
-
-    scan_control.comboBox_scan_selection.setCurrentText(scan_name)
-
-    # Set kwargs in the UI
-    for kwarg_box in scan_control.kwarg_boxes:
-        for widget in kwarg_box.widgets:
-            for key, value in kwargs.items():
-                if widget.arg_name == key:
-                    WidgetIO.set_value(widget, value)
-                    break
-    # Set args in the UI
-    for widget in scan_control.arg_box.widgets:
-        for key, value in args.items():
-            if widget.arg_name == key:
-                WidgetIO.set_value(widget, value)
-                break
-
-    # Run the scan
-    scan_control.button_run_scan.click()
-    time.sleep(2)
-
-    last_scan = queue.scan_storage.storage[-1]
-    assert last_scan.status_message.info["scan_name"] == scan_name
-    assert last_scan.status_message.info["exp_time"] == kwargs["exp_time"]
-    assert last_scan.status_message.info["scan_motors"] == [args["device"]]
-    assert last_scan.status_message.info["num_points"] == kwargs["steps"]