wip

.github/workflows/ci.yml

@@ -1,19 +1,19 @@
 name: Full CI
-on: 
+on:
   push:
   pull_request:
   workflow_dispatch:
     inputs:
       BEC_WIDGETS_BRANCH:
-        description: 'Branch of BEC Widgets to install'
+        description: "Branch of BEC Widgets to install"
         required: false
         type: string
       BEC_CORE_BRANCH:
-        description: 'Branch of BEC Core to install'
+        description: "Branch of BEC Core to install"
         required: false
         type: string
       OPHYD_DEVICES_BRANCH:
-        description: 'Branch of Ophyd Devices to install'
+        description: "Branch of Ophyd Devices to install"
         required: false
         type: string
 
@@ -25,60 +25,58 @@ permissions:
   pull-requests: write
 
 jobs:
-  check_pr_status:
-    uses: ./.github/workflows/check_pr.yml
+  # check_pr_status:
+  #   uses: ./.github/workflows/check_pr.yml
 
-  formatter:
-    needs: check_pr_status
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/formatter.yml
+  # formatter:
+  #   needs: check_pr_status
+  #   if: needs.check_pr_status.outputs.branch-pr == ''
+  #   uses: ./.github/workflows/formatter.yml
 
-  unit-test:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/pytest.yml
-    with:
-      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref }}
-      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main' }}
-    secrets:
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+  # unit-test:
+  #   needs: [check_pr_status, formatter]
+  #   if: needs.check_pr_status.outputs.branch-pr == ''
+  #   uses: ./.github/workflows/pytest.yml
+  #   with:
+  #     BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref }}
+  #     BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
+  #     OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main' }}
+  #   secrets:
+  #     CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
-  unit-test-matrix:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/pytest-matrix.yml
-    with:
-      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha}}
-      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main' }}
+  # unit-test-matrix:
+  #   needs: [check_pr_status, formatter]
+  #   if: needs.check_pr_status.outputs.branch-pr == ''
+  #   uses: ./.github/workflows/pytest-matrix.yml
+  #   with:
+  #     BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha}}
+  #     BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
+  #     OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main' }}
 
-  generate-cli-test:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/generate-cli-check.yml
+  # generate-cli-test:
+  #   needs: [check_pr_status, formatter]
+  #   if: needs.check_pr_status.outputs.branch-pr == ''
+  #   uses: ./.github/workflows/generate-cli-check.yml
 
   end2end-test:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
     uses: ./.github/workflows/end2end-conda.yml
 
-  child-repos:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/child_repos.yml
-    with:
-      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main'}} 
-      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha }}
-  
-  plugin_repos:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: bec-project/bec/.github/workflows/plugin_repos.yml@main
-    with:
-      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha }}
+  # child-repos:
+  #   needs: [check_pr_status, formatter]
+  #   if: needs.check_pr_status.outputs.branch-pr == ''
+  #   uses: ./.github/workflows/child_repos.yml
+  #   with:
+  #     BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
+  #     OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main'}}
+  #     BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha }}
 
-    secrets:
-      GH_READ_TOKEN: ${{ secrets.GH_READ_TOKEN }}
+  # plugin_repos:
+  #   needs: [check_pr_status, formatter]
+  #   if: needs.check_pr_status.outputs.branch-pr == ''
+  #   uses: bec-project/bec/.github/workflows/plugin_repos.yml@main
+  #   with:
+  #     BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
+  #     BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha }}
+
+  #   secrets:
+  #     GH_READ_TOKEN: ${{ secrets.GH_READ_TOKEN }}

.github/workflows/end2end-conda.yml

@@ -48,12 +48,14 @@ jobs:
           source ./bin/install_bec_dev.sh -t
           cd ../
           pip install -e ./ophyd_devices -e .[dev,pyside6] -e ./bec_testing_plugin
-          pytest -v --files-path ./ --start-servers --random-order  ./tests/end-2-end
+          pip install pytest-repeat
+
+          pytest -v --files-path ./ --start-servers --random-order  ./tests/end-2-end/user_interaction/test_user_interaction_e2e.py
 
       - name: Upload logs if job fails
         if: failure()
         uses: actions/upload-artifact@v4
         with:
           name: pytest-logs
-          path: ./logs/*.log
+          path: ./bec/logs/*.log
           retention-days: 7

CHANGELOG.md

@@ -1,28 +1,6 @@
 # CHANGELOG
 
 
-## v3.2.2 (2026-03-16)
-
-### Bug Fixes
-
-- **image**: Disconnecting of 2d monitor
-  ([`4c9d7fd`](https://github.com/bec-project/bec_widgets/commit/4c9d7fddce7aa5b7f13a00ac332bd54b301e3c28))
-
-
-## v3.2.1 (2026-03-16)
-
-### Bug Fixes
-
-- **e2e**: Bec dock rpc fixed synchronization
-  ([`e061fa3`](https://github.com/bec-project/bec_widgets/commit/e061fa31a9a5e5c00e44337d7cc52c51d8e259b5))
-
-- **e2e**: Bec shell excluded from e2e testing
-  ([`974f259`](https://github.com/bec-project/bec_widgets/commit/974f25997d68d13ff1063026f9e5c4c8dd4d49f3))
-
-- **e2e**: Timeout for maybe_remove_dock_area
-  ([`718f995`](https://github.com/bec-project/bec_widgets/commit/718f99527c3bebb96845d3305aba69434eb83f77))
-
-
 ## v3.2.0 (2026-03-11)
 
 ### Features

bec_widgets/utils/rpc_server.py

@@ -118,6 +118,9 @@ class RPCServer:
         logger.debug(f"Received RPC instruction: {msg}, metadata: {metadata}")
         with rpc_exception_hook(functools.partial(self.send_response, request_id, False)):
             try:
+                logger.info(
+                    f"Processing RPC instruction: {msg['action']} with request_id: {request_id}. Parameters: {msg.get('parameter')}"
+                )
                 method = msg["action"]
                 args = msg["parameter"].get("args", [])
                 kwargs = msg["parameter"].get("kwargs", {})
@@ -257,6 +260,10 @@ class RPCServer:
             else:
                 name = WidgetContainerUtils.generate_unique_name("dock_area", existing_dock_areas)
 
+            logger.info(
+                f"Launching new dock area with name: {name} and startup_profile: {startup_profile}"
+            )
+
             result_widget = bw_launch.dock_area(object_name=name, startup_profile=startup_profile)
             result_widget.window().setWindowTitle(f"BEC - {name}")
 
@@ -296,6 +303,9 @@ class RPCServer:
             else:
                 res = self.serialize_object(res)
         except RegistryNotReadyError:
+            logger.info(
+                f"Object not registered yet for RPC request {request_id}, retrying serialization after {retry_delay} ms"
+            )
             try:
                 self._rpc_singleshot_repeats[request_id] += retry_delay
                 QTimer.singleShot(

bec_widgets/widgets/plots/image/image.py

@@ -270,16 +270,6 @@ class Image(ImageBase):
             return
 
         old_device = self._config.device
-        old_signal = self._config.signal
-        old_config = self.subscriptions["main"]
-        if old_device and old_signal and old_device != value:
-            self._disconnect_monitor_subscription(
-                device=old_device,
-                signal=old_signal,
-                source=old_config.source,
-                async_update=self.async_update,
-                async_signal_name=old_config.async_signal_name,
-            )
         self._config.device = value
 
         # If we have a signal, reconnect with the new device
@@ -335,16 +325,6 @@ class Image(ImageBase):
                 self._set_connection_status("disconnected")
             return
 
-        old_signal = self._config.signal
-        old_config = self.subscriptions["main"]
-        if self._config.device and old_signal and old_signal != value:
-            self._disconnect_monitor_subscription(
-                device=self._config.device,
-                signal=old_signal,
-                source=old_config.source,
-                async_update=self.async_update,
-                async_signal_name=old_config.async_signal_name,
-            )
         self._config.signal = value
 
         # If we have a device, try to connect
@@ -467,61 +447,6 @@ class Image(ImageBase):
         )
         self._autorange_on_next_update = True
 
-    def _disconnect_monitor_subscription(
-        self,
-        *,
-        device: str,
-        signal: str,
-        source: Literal["device_monitor_1d", "device_monitor_2d"] | None,
-        async_update: bool,
-        async_signal_name: str | None,
-    ) -> None:
-        if not device or not signal:
-            return
-
-        if async_update:
-            async_signal_name = async_signal_name or signal
-            ids_to_check = [self.scan_id, self.old_scan_id]
-
-            if source == "device_monitor_1d":
-                for scan_id in ids_to_check:
-                    if scan_id is None:
-                        continue
-                    self.bec_dispatcher.disconnect_slot(
-                        self.on_image_update_1d,
-                        MessageEndpoints.device_async_signal(scan_id, device, async_signal_name),
-                    )
-                    logger.info(
-                        f"Disconnecting 1d update ScanID:{scan_id}, Device Name:{device},Device Entry:{async_signal_name}"
-                    )
-            elif source == "device_monitor_2d":
-                for scan_id in ids_to_check:
-                    if scan_id is None:
-                        continue
-                    self.bec_dispatcher.disconnect_slot(
-                        self.on_image_update_2d,
-                        MessageEndpoints.device_async_signal(scan_id, device, async_signal_name),
-                    )
-                    logger.info(
-                        f"Disconnecting 2d update ScanID:{scan_id}, Device Name:{device},Device Entry:{async_signal_name}"
-                    )
-            return
-
-        if source == "device_monitor_1d":
-            self.bec_dispatcher.disconnect_slot(
-                self.on_image_update_1d, MessageEndpoints.device_preview(device, signal)
-            )
-            logger.info(
-                f"Disconnecting preview 1d update Device Name:{device}, Device Entry:{signal}"
-            )
-        elif source == "device_monitor_2d":
-            self.bec_dispatcher.disconnect_slot(
-                self.on_image_update_2d, MessageEndpoints.device_preview(device, signal)
-            )
-            logger.info(
-                f"Disconnecting preview 2d update Device Name:{device}, Device Entry:{signal}"
-            )
-
     def _disconnect_current_monitor(self):
         """
         Internal method to disconnect the current monitor subscriptions.
@@ -530,13 +455,55 @@ class Image(ImageBase):
             return
 
         config = self.subscriptions["main"]
-        self._disconnect_monitor_subscription(
-            device=self._config.device,
-            signal=self._config.signal,
-            source=config.source,
-            async_update=self.async_update,
-            async_signal_name=config.async_signal_name,
-        )
+
+        if self.async_update:
+            async_signal_name = config.async_signal_name or self._config.signal
+            ids_to_check = [self.scan_id, self.old_scan_id]
+
+            if config.source == "device_monitor_1d":
+                for scan_id in ids_to_check:
+                    if scan_id is None:
+                        continue
+                    self.bec_dispatcher.disconnect_slot(
+                        self.on_image_update_1d,
+                        MessageEndpoints.device_async_signal(
+                            scan_id, self._config.device, async_signal_name
+                        ),
+                    )
+                    logger.info(
+                        f"Disconnecting 1d update ScanID:{scan_id}, Device Name:{self._config.device},Device Entry:{async_signal_name}"
+                    )
+            elif config.source == "device_monitor_2d":
+                for scan_id in ids_to_check:
+                    if scan_id is None:
+                        continue
+                    self.bec_dispatcher.disconnect_slot(
+                        self.on_image_update_2d,
+                        MessageEndpoints.device_async_signal(
+                            scan_id, self._config.device, async_signal_name
+                        ),
+                    )
+                    logger.info(
+                        f"Disconnecting 2d update ScanID:{scan_id}, Device Name:{self._config.device},Device Entry:{async_signal_name}"
+                    )
+
+        else:
+            if config.source == "device_monitor_1d":
+                self.bec_dispatcher.disconnect_slot(
+                    self.on_image_update_1d,
+                    MessageEndpoints.device_preview(self._config.device, self._config.signal),
+                )
+                logger.info(
+                    f"Disconnecting preview 1d update Device Name:{self._config.device}, Device Entry:{self._config.signal}"
+                )
+            elif config.source == "device_monitor_2d":
+                self.bec_dispatcher.disconnect_slot(
+                    self.on_image_update_2d,
+                    MessageEndpoints.device_preview(self._config.device, self._config.signal),
+                )
+                logger.info(
+                    f"Disconnecting preview 2d update Device Name:{self._config.device}, Device Entry:{self._config.signal}"
+                )
 
         # Reset async state
         self.async_update = False
@@ -893,19 +860,45 @@ class Image(ImageBase):
             logger.warning("Cannot disconnect monitor without both device and signal")
             return
 
-        if config.source not in {"device_monitor_1d", "device_monitor_2d"}:
-            logger.warning(
-                f"Cannot disconnect monitor {target_device}.{target_entry} with source {self.subscriptions['main'].source}"
-            )
-            return
-
-        self._disconnect_monitor_subscription(
-            device=target_device,
-            signal=target_entry,
-            source=config.source,
-            async_update=self.async_update,
-            async_signal_name=config.async_signal_name,
-        )
+        if self.async_update:
+            async_signal_name = config.async_signal_name or target_entry
+            ids_to_check = [self.scan_id, self.old_scan_id]
+            if config.source == "device_monitor_1d":
+                for scan_id in ids_to_check:
+                    if scan_id is None:
+                        continue
+                    self.bec_dispatcher.disconnect_slot(
+                        self.on_image_update_1d,
+                        MessageEndpoints.device_async_signal(
+                            scan_id, target_device, async_signal_name
+                        ),
+                    )
+            elif config.source == "device_monitor_2d":
+                for scan_id in ids_to_check:
+                    if scan_id is None:
+                        continue
+                    self.bec_dispatcher.disconnect_slot(
+                        self.on_image_update_2d,
+                        MessageEndpoints.device_async_signal(
+                            scan_id, target_device, async_signal_name
+                        ),
+                    )
+        else:
+            if config.source == "device_monitor_1d":
+                self.bec_dispatcher.disconnect_slot(
+                    self.on_image_update_1d,
+                    MessageEndpoints.device_preview(target_device, target_entry),
+                )
+            elif config.source == "device_monitor_2d":
+                self.bec_dispatcher.disconnect_slot(
+                    self.on_image_update_2d,
+                    MessageEndpoints.device_preview(target_device, target_entry),
+                )
+            else:
+                logger.warning(
+                    f"Cannot disconnect monitor {target_device}.{target_entry} with source {self.subscriptions['main'].source}"
+                )
+                return
 
         self.subscriptions["main"].async_signal_name = None
         self.async_update = False

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "3.2.2"
+version = "3.2.0"
 description = "BEC Widgets"
 requires-python = ">=3.11"
 classifiers = [

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -75,13 +75,6 @@ def test_dock_manipulations_e2e(qtbot, connected_client_gui_obj):
     w1 = dock_area.new("Waveform")
     w2 = dock_area.new("Waveform")
 
-    qtbot.waitUntil(
-        lambda: all(
-            gui_id in gui._server_registry for gui_id in [w0._gui_id, w1._gui_id, w2._gui_id]
-        ),
-        timeout=5000,
-    )
-
     assert hasattr(gui.bec, "Waveform")
     assert hasattr(gui.bec, "Waveform_0")
     assert hasattr(gui.bec, "Waveform_1")
@@ -133,7 +126,6 @@ def test_rpc_gui_obj(connected_client_gui_obj, qtbot):
 
     xw = gui.new("X")
     xw.delete_all()
-    qtbot.waitUntil(lambda: len(gui.windows) == 2, timeout=3000)
     assert xw.__class__.__name__ == "RPCReference"
     assert gui._ipython_registry[xw._gui_id].__class__.__name__ == "BECDockArea"
     assert len(gui.windows) == 2
@@ -153,15 +145,14 @@ def test_rpc_gui_obj(connected_client_gui_obj, qtbot):
 
     qtbot.waitUntil(wait_for_gui_started, timeout=3000)
     # gui.windows should have bec with gui_id 'bec'
-    qtbot.waitUntil(lambda: len(gui.windows) == 1, timeout=3000)
     assert len(gui.windows) == 1
 
     # communication should work, main dock area should have same id and be visible
 
     yw = gui.new("Y")
-    yw.delete_all()
     qtbot.waitUntil(lambda: len(gui.windows) == 2, timeout=3000)
+    yw.delete_all()
     assert len(gui.windows) == 2
     yw.remove()
     qtbot.waitUntil(lambda: len(gui.windows) == 1, timeout=3000)
-    assert len(gui.windows) == 1  # only bec is left
+    assert len(gui.windows) == 1

tests/end-2-end/test_rpc_widgets_e2e.py

@@ -89,8 +89,8 @@ def test_available_widgets(qtbot, connected_client_gui_obj):
         # Skip private attributes
         if object_name.startswith("_"):
             continue
-        # Skip BECShell as ttyd is not installed
-        if object_name == "BECShell":
+        # Skip VSCode widget as Code server is not available in the Docker image
+        if object_name == "VSCodeEditor":
             continue
 
         # Skip WebConsole as ttyd is not installed

tests/end-2-end/user_interaction/test_user_interaction_e2e.py

@@ -128,147 +128,167 @@ def maybe_remove_dock_area(qtbot, gui: BECGuiClient, random_int_gen: random.Rand
     random_int = random_int_gen.randint(0, 100)
     if random_int >= 50:
         # Needed, reference gets deleted in the gui
+        name = gui.dock_area.object_name
+        gui_id = gui.dock_area._gui_id
         gui.dock_area.delete_all()  # start fresh
         gui.delete("dock_area")
+        wait_for_namespace_change(
+            qtbot, gui=gui, parent_widget=gui, object_name=name, widget_gui_id=gui_id, exists=False
+        )
         qtbot.waitUntil(lambda: hasattr(gui, "dock_area") is False, timeout=5000)
 
 
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_bec_progress_bar(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the BECProgressBar widget."""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.BECProgressBar)
-    widget: client.BECProgressBar
-
-    # Check rpc calls
-    assert widget.label_template == "$value / $maximum - $percentage %"
-    widget.set_maximum(100)
-    widget.set_minimum(50)
-    widget.set_value(75)
-
-    assert widget._get_label() == "75 / 100 - 50 %"
-
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
-
-
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_bec_queue(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the BECQueue widget."""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.BECQueue)
-    widget: client.BECQueue
-
-    # No rpc calls to test so far
-    #  maybe we can add an rpc call to check the queue length
-
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
-
-
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_bec_status_box(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the BECStatusBox widget."""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.BECStatusBox)
-
-    # Check rpc calls
-    assert widget.get_server_state() in ["RUNNING", "IDLE", "BUSY", "ERROR"]
-
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
-
-
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_dap_combo_box(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the DAPComboBox widget."""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.DapComboBox)
-    widget: client.DAPComboBox
-
-    # Check rpc calls
-    widget.select_fit_model("PseudoVoigtModel")
-    widget.select_x_axis("samx")
-    widget.select_y_axis("bpm4i")
-
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
-
-
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_device_browser(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the DeviceBrowser widget."""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.DeviceBrowser)
-    widget: client.DeviceBrowser
-
-    # No rpc calls yet to check
-
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
-
-
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_image(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the Image widget."""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.Image)
-    widget: client.Image
-
-    scans = bec.scans
-    dev = bec.device_manager.devices
-    # Test rpc calls
-    img = widget.image(device=dev.eiger.name, signal="preview")
-    assert img.get_data() is None
-    # Run a scan and plot the image
-    s = scans.line_scan(dev.samx, -3, 3, steps=50, exp_time=0.01, relative=False)
-    s.wait()
-
-    def _wait_for_scan_in_history():
-        # Get scan item from history
-        scan_item = bec.history.get_by_scan_id(s.scan.scan_id)
-        return scan_item is not None
-
-    qtbot.waitUntil(_wait_for_scan_in_history, timeout=7000)
-
-    # Check that last image is equivalent to data in Redis
-    last_img = bec.connector.get_last(MessageEndpoints.device_preview("eiger", "preview"))[
-        "data"
-    ].data
-    assert np.allclose(img.get_data(), last_img)
-
-    # Now add a device with a preview signal
-    img = widget.image(device="eiger", signal="preview")
-    s = scans.line_scan(dev.samx, -3, 3, steps=50, exp_time=0.01, relative=False)
-    s.wait()
-
-    qtbot.waitUntil(_wait_for_scan_in_history, timeout=7000)
-
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
-
-
-# TODO re-enable when issue is resolved #560
 # @pytest.mark.timeout(PYTEST_TIMEOUT)
-# def test_widgets_e2e_log_panel(qtbot, connected_client_gui_obj, random_generator_from_seed):
-#     """Test the LogPanel widget."""
+# def test_widgets_e2e_bec_progress_bar(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the BECProgressBar widget."""
 #     gui = connected_client_gui_obj
 #     bec = gui._client
 #     # Create dock_area and widget
-#     widget = create_widget(qtbot, gui, gui.available_widgets.LogPanel)
-#     widget: client.LogPanel
+#     widget = create_widget(qtbot, gui, gui.available_widgets.BECProgressBar)
+#     widget: client.BECProgressBar
+
+#     # Check rpc calls
+#     assert widget.label_template == "$value / $maximum - $percentage %"
+#     widget.set_maximum(100)
+#     widget.set_minimum(50)
+#     widget.set_value(75)
+
+#     assert widget._get_label() == "75 / 100 - 50 %"
+
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+
+
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_bec_queue(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the BECQueue widget."""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.BECQueue)
+#     widget: client.BECQueue
+
+#     # No rpc calls to test so far
+#     #  maybe we can add an rpc call to check the queue length
+
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+
+
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_bec_status_box(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the BECStatusBox widget."""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.BECStatusBox)
+
+#     # Check rpc calls
+#     assert widget.get_server_state() in ["RUNNING", "IDLE", "BUSY", "ERROR"]
+
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+
+
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_dap_combo_box(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the DAPComboBox widget."""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.DapComboBox)
+#     widget: client.DAPComboBox
+
+#     # Check rpc calls
+#     widget.select_fit_model("PseudoVoigtModel")
+#     widget.select_x_axis("samx")
+#     widget.select_y_axis("bpm4i")
+
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+
+
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_device_browser(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the DeviceBrowser widget."""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.DeviceBrowser)
+#     widget: client.DeviceBrowser
+
+#     # No rpc calls yet to check
+
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+
+
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_image(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the Image widget."""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.Image)
+#     widget: client.Image
+
+#     scans = bec.scans
+#     dev = bec.device_manager.devices
+#     # Test rpc calls
+#     img = widget.image(device=dev.eiger.name, signal="preview")
+#     assert img.get_data() is None
+#     # Run a scan and plot the image
+#     s = scans.line_scan(dev.samx, -3, 3, steps=50, exp_time=0.01, relative=False)
+#     s.wait()
+
+#     def _wait_for_scan_in_history():
+#         # Get scan item from history
+#         scan_item = bec.history.get_by_scan_id(s.scan.scan_id)
+#         return scan_item is not None
+
+#     qtbot.waitUntil(_wait_for_scan_in_history, timeout=7000)
+
+#     # Check that last image is equivalent to data in Redis
+#     last_img = bec.connector.get_last(MessageEndpoints.device_preview("eiger", "preview"))[
+#         "data"
+#     ].data
+#     assert np.allclose(img.get_data(), last_img)
+
+#     # Now add a device with a preview signal
+#     img = widget.image(device="eiger", signal="preview")
+#     s = scans.line_scan(dev.samx, -3, 3, steps=50, exp_time=0.01, relative=False)
+#     s.wait()
+
+#     qtbot.waitUntil(_wait_for_scan_in_history, timeout=7000)
+
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+
+
+# # TODO re-enable when issue is resolved #560
+# # @pytest.mark.timeout(PYTEST_TIMEOUT)
+# # def test_widgets_e2e_log_panel(qtbot, connected_client_gui_obj, random_generator_from_seed):
+# #     """Test the LogPanel widget."""
+# #     gui = connected_client_gui_obj
+# #     bec = gui._client
+# #     # Create dock_area and widget
+# #     widget = create_widget(qtbot, gui, gui.available_widgets.LogPanel)
+# #     widget: client.LogPanel
+
+# #     # No rpc calls to check so far
+
+# #     # Test removing the widget, or leaving it open for the next test
+# #     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+
+
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_minesweeper(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the MineSweeper widget."""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.Minesweeper)
+#     widget: client.MineSweeper
 
 #     # No rpc calls to check so far
 
@@ -276,175 +296,160 @@ def test_widgets_e2e_image(qtbot, connected_client_gui_obj, random_generator_fro
 #     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_minesweeper(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the MineSweeper widget."""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.Minesweeper)
-    widget: client.MineSweeper
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_motor_map(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the MotorMap widget."""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.MotorMap)
+#     widget: client.MotorMap
 
-    # No rpc calls to check so far
+#     # Test RPC calls
+#     dev = bec.device_manager.devices
+#     scans = bec.scans
+#     # Set motor map to names
+#     widget.map(dev.samx, dev.samy)
+#     # Move motor samx to pos
+#     pos = dev.samx.limits[1] - 1  # -1 from higher limit
+#     scans.mv(dev.samx, pos, relative=False).wait()
+#     # Check that data is up to date
+#     assert np.isclose(widget.get_data()["x"][-1], pos, dev.samx.precision)
+#     # Move motor samy to pos
+#     pos = dev.samy.limits[0] + 1  # +1 from lower limit
+#     scans.mv(dev.samy, pos, relative=False).wait()
+#     # Check that data is up to date
+#     assert np.isclose(widget.get_data()["y"][-1], pos, dev.samy.precision)
 
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_motor_map(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the MotorMap widget."""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.MotorMap)
-    widget: client.MotorMap
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_multi_waveform(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test MultiWaveform widget."""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.MultiWaveform)
+#     widget: client.MultiWaveform
 
-    # Test RPC calls
-    dev = bec.device_manager.devices
-    scans = bec.scans
-    # Set motor map to names
-    widget.map(dev.samx, dev.samy)
-    # Move motor samx to pos
-    pos = dev.samx.limits[1] - 1  # -1 from higher limit
-    scans.mv(dev.samx, pos, relative=False).wait()
-    # Check that data is up to date
-    assert np.isclose(widget.get_data()["x"][-1], pos, dev.samx.precision)
-    # Move motor samy to pos
-    pos = dev.samy.limits[0] + 1  # +1 from lower limit
-    scans.mv(dev.samy, pos, relative=False).wait()
-    # Check that data is up to date
-    assert np.isclose(widget.get_data()["y"][-1], pos, dev.samy.precision)
+#     # Test RPC calls
+#     dev = bec.device_manager.devices
+#     scans = bec.scans
+#     # test plotting
+#     cm = "cividis"
+#     widget.plot(dev.waveform, color_palette=cm)
+#     assert widget.monitor == dev.waveform.name
+#     assert widget.color_palette == cm
 
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+#     # Scan with BEC
+#     s = scans.line_scan(dev.samx, -3, 3, steps=5, exp_time=0.01, relative=False)
+#     s.wait()
+
+#     def _wait_for_scan_in_history():
+#         # Get scan item from history
+#         scan_item = bec.history.get_by_scan_id(s.scan.scan_id)
+#         return scan_item is not None
+
+#     qtbot.waitUntil(_wait_for_scan_in_history, timeout=7000)
+#     # Wait for data in history (should be plotted?)
+
+#     # TODO how can we check that the data was plotted, implement get_data()
+
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_multi_waveform(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test MultiWaveform widget."""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.MultiWaveform)
-    widget: client.MultiWaveform
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_positioner_indicator(
+#     qtbot, connected_client_gui_obj, random_generator_from_seed
+# ):
+#     """Test the PositionIndicator widget."""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.PositionIndicator)
+#     widget: client.PositionIndicator
 
-    # Test RPC calls
-    dev = bec.device_manager.devices
-    scans = bec.scans
-    # test plotting
-    cm = "cividis"
-    widget.plot(dev.waveform, color_palette=cm)
-    assert widget.monitor == dev.waveform.name
-    assert widget.color_palette == cm
+#     # TODO check what these rpc calls are supposed to do! Issue created #461
+#     widget.set_value(5)
 
-    # Scan with BEC
-    s = scans.line_scan(dev.samx, -3, 3, steps=5, exp_time=0.01, relative=False)
-    s.wait()
-
-    def _wait_for_scan_in_history():
-        # Get scan item from history
-        scan_item = bec.history.get_by_scan_id(s.scan.scan_id)
-        return scan_item is not None
-
-    qtbot.waitUntil(_wait_for_scan_in_history, timeout=7000)
-    # Wait for data in history (should be plotted?)
-
-    # TODO how can we check that the data was plotted, implement get_data()
-
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_positioner_indicator(
-    qtbot, connected_client_gui_obj, random_generator_from_seed
-):
-    """Test the PositionIndicator widget."""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.PositionIndicator)
-    widget: client.PositionIndicator
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_positioner_box(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the PositionerBox widget."""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.PositionerBox)
+#     widget: client.PositionerBox
 
-    # TODO check what these rpc calls are supposed to do! Issue created #461
-    widget.set_value(5)
+#     # Test rpc calls
+#     dev = bec.device_manager.devices
+#     scans = bec.scans
+#     # No rpc calls to check so far
+#     widget.set_positioner(dev.samx)
+#     widget.set_positioner(dev.samy.name)
 
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+#     scans.mv(dev.samy, -3, relative=False).wait()
+
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_positioner_box(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the PositionerBox widget."""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.PositionerBox)
-    widget: client.PositionerBox
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_positioner_box_2d(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the PositionerBox2D widget."""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.PositionerBox2D)
+#     widget: client.PositionerBox2D
 
-    # Test rpc calls
-    dev = bec.device_manager.devices
-    scans = bec.scans
-    # No rpc calls to check so far
-    widget.set_positioner(dev.samx)
-    widget.set_positioner(dev.samy.name)
+#     # Test rpc calls
+#     dev = bec.device_manager.devices
+#     scans = bec.scans
+#     # No rpc calls to check so far
+#     widget.set_positioner_hor(dev.samx)
+#     widget.set_positioner_ver(dev.samy)
 
-    scans.mv(dev.samy, -3, relative=False).wait()
+#     # Try moving the motors
+#     scans.mv(dev.samx, 3, relative=False).wait()
+#     scans.mv(dev.samy, -3, relative=False).wait()
 
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_positioner_box_2d(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the PositionerBox2D widget."""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.PositionerBox2D)
-    widget: client.PositionerBox2D
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_positioner_control_line(
+#     qtbot, connected_client_gui_obj, random_generator_from_seed
+# ):
+#     """Test the positioner control line widget"""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.PositionerControlLine)
+#     widget: client.PositionerControlLine
 
-    # Test rpc calls
-    dev = bec.device_manager.devices
-    scans = bec.scans
-    # No rpc calls to check so far
-    widget.set_positioner_hor(dev.samx)
-    widget.set_positioner_ver(dev.samy)
+#     # Test rpc calls
+#     dev = bec.device_manager.devices
+#     scans = bec.scans
+#     # Set positioner
+#     widget.set_positioner(dev.samx)
+#     scans.mv(dev.samx, 3, relative=False).wait()
+#     widget.set_positioner(dev.samy.name)
+#     scans.mv(dev.samy, -3, relative=False).wait()
 
-    # Try moving the motors
-    scans.mv(dev.samx, 3, relative=False).wait()
-    scans.mv(dev.samy, -3, relative=False).wait()
-
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_positioner_control_line(
-    qtbot, connected_client_gui_obj, random_generator_from_seed
-):
-    """Test the positioner control line widget"""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.PositionerControlLine)
-    widget: client.PositionerControlLine
-
-    # Test rpc calls
-    dev = bec.device_manager.devices
-    scans = bec.scans
-    # Set positioner
-    widget.set_positioner(dev.samx)
-    scans.mv(dev.samx, 3, relative=False).wait()
-    widget.set_positioner(dev.samy.name)
-    scans.mv(dev.samy, -3, relative=False).wait()
-
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
-
-
-# TODO passes locally, fails on CI for some reason... -> issue #1003
+@pytest.mark.repeat(20)
 @pytest.mark.timeout(PYTEST_TIMEOUT)
 def test_widgets_e2e_ring_progress_bar(qtbot, connected_client_gui_obj, random_generator_from_seed):
     """Test the RingProgressBar widget"""
@@ -473,86 +478,86 @@ def test_widgets_e2e_ring_progress_bar(qtbot, connected_client_gui_obj, random_g
     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_scan_control(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the ScanControl widget"""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.ScanControl)
-    widget: client.ScanControl
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_scan_control(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the ScanControl widget"""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.ScanControl)
+#     widget: client.ScanControl
 
-    # No rpc calls to check so far
+#     # No rpc calls to check so far
 
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_scatter_waveform(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the ScatterWaveform widget"""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.ScatterWaveform)
-    widget: client.ScatterWaveform
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_scatter_waveform(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the ScatterWaveform widget"""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.ScatterWaveform)
+#     widget: client.ScatterWaveform
 
-    # Test rpc calls
-    dev = bec.device_manager.devices
-    scans = bec.scans
-    widget.plot(dev.samx, dev.samy, dev.bpm4i)
-    scans.grid_scan(dev.samx, -5, 5, 5, dev.samy, -5, 5, 5, exp_time=0.01, relative=False).wait()
+#     # Test rpc calls
+#     dev = bec.device_manager.devices
+#     scans = bec.scans
+#     widget.plot(dev.samx, dev.samy, dev.bpm4i)
+#     scans.grid_scan(dev.samx, -5, 5, 5, dev.samy, -5, 5, 5, exp_time=0.01, relative=False).wait()
 
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_text_box(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the TextBox widget"""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.TextBox)
-    widget: client.TextBox
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_text_box(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the TextBox widget"""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.TextBox)
+#     widget: client.TextBox
 
-    # RPC calls
-    widget.set_plain_text("Hello World")
-    widget.set_html_text("<b> Hello World HTML </b>")
+#     # RPC calls
+#     widget.set_plain_text("Hello World")
+#     widget.set_html_text("<b> Hello World HTML </b>")
 
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
-@pytest.mark.timeout(PYTEST_TIMEOUT)
-def test_widgets_e2e_waveform(qtbot, connected_client_gui_obj, random_generator_from_seed):
-    """Test the Waveform widget"""
-    gui = connected_client_gui_obj
-    bec = gui._client
-    # Create dock_area and widget
-    widget = create_widget(qtbot, gui, gui.available_widgets.Waveform)
-    widget: client.Waveform
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_waveform(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the Waveform widget"""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.Waveform)
+#     widget: client.Waveform
 
-    # Test rpc calls
-    dev = bec.device_manager.devices
-    scans = bec.scans
-    widget.plot(dev.bpm4i)
-    s = scans.line_scan(dev.samx, -3, 3, steps=50, exp_time=0.01, relative=False)
-    s.wait()
+#     # Test rpc calls
+#     dev = bec.device_manager.devices
+#     scans = bec.scans
+#     widget.plot(dev.bpm4i)
+#     s = scans.line_scan(dev.samx, -3, 3, steps=50, exp_time=0.01, relative=False)
+#     s.wait()
 
-    def _wait_for_scan_in_history():
-        # Get scan item from history
-        scan_item = bec.history.get_by_scan_id(s.scan.scan_id)
-        return scan_item is not None
+#     def _wait_for_scan_in_history():
+#         # Get scan item from history
+#         scan_item = bec.history.get_by_scan_id(s.scan.scan_id)
+#         return scan_item is not None
 
-    qtbot.waitUntil(_wait_for_scan_in_history, timeout=7000)
+#     qtbot.waitUntil(_wait_for_scan_in_history, timeout=7000)
 
-    scan_item = bec.history.get_by_scan_id(s.scan.scan_id)
-    samx_data = scan_item.devices.samx.samx.read()["value"]
-    bpm4i_data = scan_item.devices.bpm4i.bpm4i.read()["value"]
-    curve = widget.curves[0]
-    assert np.allclose(curve.get_data()[0], samx_data)
-    assert np.allclose(curve.get_data()[1], bpm4i_data)
+#     scan_item = bec.history.get_by_scan_id(s.scan.scan_id)
+#     samx_data = scan_item.devices.samx.samx.read()["value"]
+#     bpm4i_data = scan_item.devices.bpm4i.bpm4i.read()["value"]
+#     curve = widget.curves[0]
+#     assert np.allclose(curve.get_data()[0], samx_data)
+#     assert np.allclose(curve.get_data()[1], bpm4i_data)
 
-    # Test removing the widget, or leaving it open for the next test
-    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)

tests/unit_tests/test_image_view_next_gen.py

@@ -197,163 +197,6 @@ def test_image_setup_preview_signal_2d(qtbot, mocked_client):
     np.testing.assert_array_equal(view.main_image.image, test_data)
 
 
-def test_switching_device_disconnects_previous_preview_endpoint(qtbot, mocked_client, monkeypatch):
-    view = create_widget(qtbot, Image, client=mocked_client)
-    _set_signal_config(mocked_client, "eiger", "img", signal_class="PreviewSignal", ndim=2)
-    _set_signal_config(mocked_client, "waveform1d", "img", signal_class="PreviewSignal", ndim=2)
-
-    connected = []
-    disconnected = []
-    monkeypatch.setattr(
-        view.bec_dispatcher,
-        "connect_slot",
-        lambda slot, endpoint, *args, **kwargs: connected.append(endpoint),
-    )
-    monkeypatch.setattr(
-        view.bec_dispatcher,
-        "disconnect_slot",
-        lambda slot, endpoint, *args, **kwargs: disconnected.append(endpoint),
-    )
-
-    view.image(device="eiger", signal="img")
-    connected.clear()
-    disconnected.clear()
-
-    view.device = "waveform1d"
-
-    assert MessageEndpoints.device_preview("eiger", "img") in disconnected
-    assert MessageEndpoints.device_preview("waveform1d", "img") in connected
-
-
-def test_switching_device_disconnects_previous_async_endpoint(qtbot, mocked_client, monkeypatch):
-    """
-    Verify that switching device while async_update=True disconnects device_async_signal
-    endpoints for both scan_id and old_scan_id on the old device before reconnecting to
-    the new device.
-    """
-    view = create_widget(qtbot, Image, client=mocked_client)
-    _set_signal_config(
-        mocked_client, "eiger", "img", signal_class="AsyncSignal", ndim=2, obj_name="async_obj"
-    )
-    _set_signal_config(
-        mocked_client, "waveform1d", "img", signal_class="AsyncSignal", ndim=2, obj_name="async_obj"
-    )
-
-    connected = []
-    disconnected = []
-    monkeypatch.setattr(
-        view.bec_dispatcher,
-        "connect_slot",
-        lambda slot, endpoint, *args, **kwargs: connected.append(endpoint),
-    )
-    monkeypatch.setattr(
-        view.bec_dispatcher,
-        "disconnect_slot",
-        lambda slot, endpoint, *args, **kwargs: disconnected.append(endpoint),
-    )
-
-    view.image(device="eiger", signal="img")
-    assert view.async_update is True
-    assert view.subscriptions["main"].async_signal_name == "async_obj"
-
-    view.scan_id = "scan_current"
-    view.old_scan_id = "scan_previous"
-    connected.clear()
-    disconnected.clear()
-
-    view.device = "waveform1d"
-
-    # Both scan_id and old_scan_id endpoints for the old device must be disconnected
-    assert (
-        MessageEndpoints.device_async_signal("scan_current", "eiger", "async_obj") in disconnected
-    )
-    assert (
-        MessageEndpoints.device_async_signal("scan_previous", "eiger", "async_obj") in disconnected
-    )
-    # The new device's async endpoint for the current scan must be connected
-    assert (
-        MessageEndpoints.device_async_signal("scan_current", "waveform1d", "async_obj") in connected
-    )
-
-
-def test_switching_signal_disconnects_previous_preview_endpoint(qtbot, mocked_client, monkeypatch):
-    view = create_widget(qtbot, Image, client=mocked_client)
-    _set_signal_config(mocked_client, "eiger", "img_a", signal_class="PreviewSignal", ndim=2)
-    _set_signal_config(mocked_client, "eiger", "img_b", signal_class="PreviewSignal", ndim=2)
-
-    connected = []
-    disconnected = []
-    monkeypatch.setattr(
-        view.bec_dispatcher,
-        "connect_slot",
-        lambda slot, endpoint, *args, **kwargs: connected.append(endpoint),
-    )
-    monkeypatch.setattr(
-        view.bec_dispatcher,
-        "disconnect_slot",
-        lambda slot, endpoint, *args, **kwargs: disconnected.append(endpoint),
-    )
-
-    view.image(device="eiger", signal="img_a")
-    connected.clear()
-    disconnected.clear()
-
-    view.signal = "img_b"
-
-    assert MessageEndpoints.device_preview("eiger", "img_a") in disconnected
-    assert MessageEndpoints.device_preview("eiger", "img_b") in connected
-
-
-def test_switching_signal_disconnects_previous_async_endpoint(qtbot, mocked_client, monkeypatch):
-    """
-    When the current monitor is an async signal, switching to a different signal must
-    disconnect the previous async endpoint (based on scan_id/async_signal_name) before
-    reconnecting with the new signal's async endpoint.
-    """
-    view = create_widget(qtbot, Image, client=mocked_client)
-    _set_signal_config(
-        mocked_client, "eiger", "img_a", signal_class="AsyncSignal", ndim=2, obj_name="async_obj_a"
-    )
-    _set_signal_config(
-        mocked_client, "eiger", "img_b", signal_class="AsyncSignal", ndim=2, obj_name="async_obj_b"
-    )
-
-    connected = []
-    disconnected = []
-    monkeypatch.setattr(
-        view.bec_dispatcher,
-        "connect_slot",
-        lambda slot, endpoint, *args, **kwargs: connected.append(endpoint),
-    )
-    monkeypatch.setattr(
-        view.bec_dispatcher,
-        "disconnect_slot",
-        lambda slot, endpoint, *args, **kwargs: disconnected.append(endpoint),
-    )
-
-    # Connect to img_a as an async signal; scan_id is None so no actual subscription is made
-    view.image(device="eiger", signal="img_a")
-    assert view.async_update is True
-    assert view.subscriptions["main"].async_signal_name == "async_obj_a"
-    assert view.subscriptions["main"].source == "device_monitor_2d"
-
-    # Simulate an active scan so that the async endpoint is real
-    view.scan_id = "scan_123"
-    connected.clear()
-    disconnected.clear()
-
-    # Switch to a different signal
-    view.signal = "img_b"
-
-    # The previous async endpoint for img_a must have been disconnected
-    expected_disconnect = MessageEndpoints.device_async_signal("scan_123", "eiger", "async_obj_a")
-    assert expected_disconnect in disconnected
-
-    # The new async endpoint for img_b must have been connected
-    expected_connect = MessageEndpoints.device_async_signal("scan_123", "eiger", "async_obj_b")
-    assert expected_connect in connected
-
-
 def test_preview_signals_skip_0d_entries(qtbot, mocked_client, monkeypatch):
     """
     Preview/async combobox should omit 0‑D signals.