WIP first try

.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,58 +25,60 @@ 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 }}
+  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 }}
 
-  # 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 }}
+    secrets:
+      GH_READ_TOKEN: ${{ secrets.GH_READ_TOKEN }}

.github/workflows/end2end-conda.yml

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

bec_widgets/utils/rpc_server.py

@@ -106,6 +106,8 @@ class RPCServer:
         self._registry_update_callbacks = []
         self._broadcasted_data = {}
         self._rpc_singleshot_repeats: dict[str, SingleshotRPCRepeat] = {}
+        self._top_level_rpc_windows: dict[str, QWidget] = {}
+        self._top_level_rpc_widgets: dict[str, QWidget] = {}
 
         self.status = messages.BECStatus.RUNNING
         logger.success(f"Server started with gui_id: {self.gui_id}")
@@ -118,9 +120,6 @@ 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", {})
@@ -243,8 +242,25 @@ class RPCServer:
             return {"system.launch_dock_area": True}
         raise ValueError(f"Unknown system RPC method: {method}")
 
-    @staticmethod
+    def _track_top_level_rpc_widget(self, widget: QWidget, window: QWidget | None = None) -> None:
+        gui_id = getattr(widget, "gui_id", None)
+        if not gui_id:
+            return
+
+        self._top_level_rpc_widgets[gui_id] = widget
+        if window is not None:
+            self._top_level_rpc_windows[gui_id] = window
+
+        def _cleanup_refs(*_args, tracked_gui_id=gui_id):
+            self._top_level_rpc_widgets.pop(tracked_gui_id, None)
+            self._top_level_rpc_windows.pop(tracked_gui_id, None)
+
+        widget.destroyed.connect(_cleanup_refs)
+        if window is not None and window is not widget:
+            window.destroyed.connect(_cleanup_refs)
+
     def _launch_dock_area(
+        self,
         name: str | None = None,
         geometry: tuple[int, int, int, int] | None = None,
         startup_profile: str | Literal["restore", "skip"] | None = None,
@@ -260,22 +276,20 @@ 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}")
 
             if isinstance(result_widget, BECMainWindow):
                 apply_window_geometry(result_widget, geometry)
                 result_widget.show()
+                self._track_top_level_rpc_widget(result_widget, result_widget)
             else:
                 window = BECMainWindowNoRPC()
                 window.setCentralWidget(result_widget)
                 window.setWindowTitle(f"BEC - {result_widget.objectName()}")
                 apply_window_geometry(window, geometry)
                 window.show()
+                self._track_top_level_rpc_widget(result_widget, window)
             return result_widget
 
     def serialize_result_and_send(self, request_id: str, res: object):
@@ -303,9 +317,6 @@ 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(

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -150,9 +150,7 @@ def test_rpc_gui_obj(connected_client_gui_obj, qtbot):
     # communication should work, main dock area should have same id and be visible
 
     yw = gui.new("Y")
-    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
+    assert len(gui.windows) == 1  # only bec is left

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

@@ -135,160 +135,144 @@ def maybe_remove_dock_area(qtbot, gui: BECGuiClient, random_int_gen: random.Rand
         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_bec_progress_bar(qtbot, connected_client_gui_obj, random_generator_from_seed):
-#     """Test the BECProgressBar widget."""
+# 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.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
+#     widget = create_widget(qtbot, gui, gui.available_widgets.LogPanel)
+#     widget: client.LogPanel
 
 #     # No rpc calls to check so far
 
@@ -296,160 +280,175 @@ def maybe_remove_dock_area(qtbot, gui: BECGuiClient, random_int_gen: random.Rand
 #     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_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
 
-#     # 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)
+    # 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_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_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
 
-#     # 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 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)
 
-#     # 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_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
 
-#     # 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
+    # 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_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_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
-#     # No rpc calls to check so far
-#     widget.set_positioner(dev.samx)
-#     widget.set_positioner(dev.samy.name)
+    # TODO check what these rpc calls are supposed to do! Issue created #461
+    widget.set_value(5)
 
-#     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_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
 
-#     # 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
+    # No rpc calls to check so far
+    widget.set_positioner(dev.samx)
+    widget.set_positioner(dev.samy.name)
 
-#     # Try moving the motors
-#     scans.mv(dev.samx, 3, relative=False).wait()
-#     scans.mv(dev.samy, -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
+@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
-#     # 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 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 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)
+    # 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)
 
 
-@pytest.mark.repeat(20)
+@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.timeout(PYTEST_TIMEOUT)
 def test_widgets_e2e_ring_progress_bar(qtbot, connected_client_gui_obj, random_generator_from_seed):
     """Test the RingProgressBar widget"""
@@ -478,86 +477,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_rpc_server.py

@@ -7,6 +7,7 @@ from qtpy.QtWidgets import QWidget
 
 from bec_widgets.cli.server import GUIServer
 from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.widgets.containers.main_window.main_window import BECMainWindowNoRPC
 from bec_widgets.utils.rpc_server import RegistryNotReadyError, RPCServer, SingleshotRPCRepeat
 
 from .client_mocks import mocked_client
@@ -171,3 +172,27 @@ def test_run_rpc_delegates_to_rpc_content_class(rpc_server):
     assert rpc_server.run_rpc(view, "mode", [], {}) == "initial"
     assert rpc_server.run_rpc(view, "mode", ["creator"], {}) is None
     assert view.content.mode == "creator"
+
+
+def test_launch_dock_area_keeps_strong_references(rpc_server, qtbot):
+    class DummyDockArea(BECConnector, QWidget):
+        def __init__(self, parent=None, client=None, **kwargs):
+            super().__init__(parent=parent, client=client, root_widget=True, **kwargs)
+
+    with patch("bec_widgets.applications.bw_launch.dock_area") as mock_launch_dock_area:
+        mock_launch_dock_area.return_value = DummyDockArea(
+            client=rpc_server.client, object_name="dock_area"
+        )
+
+        result = rpc_server._launch_dock_area(name="dock_area")
+        assert result is mock_launch_dock_area.return_value
+
+        gui_id = result.gui_id
+        assert rpc_server._top_level_rpc_widgets[gui_id] is result
+        assert isinstance(rpc_server._top_level_rpc_windows[gui_id], BECMainWindowNoRPC)
+
+        window = rpc_server._top_level_rpc_windows[gui_id]
+        window.close()
+        window.deleteLater()
+        qtbot.waitUntil(lambda: gui_id not in rpc_server._top_level_rpc_windows, timeout=3000)
+        assert gui_id not in rpc_server._top_level_rpc_widgets