Merge remote-tracking branch 'Codra/develop_improve-test-coverage' into develop

Author: PierreRaybaut

.vscode/settings.json

@@ -22,7 +22,9 @@
     "python.testing.unittestEnabled": false,
     "python.testing.pytestEnabled": true,
     "python.testing.pytestPath": "pytest",
-    "python.testing.pytestArgs": [],
+    "python.testing.pytestArgs": [
+        "plotpy"
+    ],
     "[python]": {
         "editor.defaultFormatter": "charliermarsh.ruff"
     },

plotpy/items/shape/range.py

@@ -246,7 +246,9 @@ def set_range(self, _min: float, _max: float, dosignal: bool = True) -> None:
         if dosignal:
             self.plot().SIG_RANGE_CHANGED.emit(self, self._min, self._max)
 
-    def move_shape(self, old_pos: QC.QPointF, new_pos: QC.QPointF) -> None:
+    def move_shape(
+        self, old_pos: tuple[float, float], new_pos: tuple[float, float]
+    ) -> None:
         """Translate the shape such that old_pos becomes new_pos in axis coordinates
 
         Args:

plotpy/plot/base.py

@@ -1107,7 +1107,9 @@ def disable_unused_axes(self):
             self.enableAxis(self.colormap_axis)
 
     def get_items(
-        self, z_sorted: bool = False, item_type: itf.IBasePlotItem | None = None
+        self,
+        z_sorted: bool = False,
+        item_type: type[itf.IItemType | itf.IBasePlotItem] | None = None,
     ) -> list[itf.IBasePlotItem]:
         """Return widget's item list
         (items are based on IBasePlotItem's interface)

plotpy/tests/features/test_colormap_manager.py

@@ -11,34 +11,58 @@
 
 # guitest: show
 
+import pytest
 import qtpy.QtCore as QC
 import qtpy.QtGui as QG
 from guidata.env import execenv
 from guidata.qthelpers import exec_dialog, qt_app_context
 
-from plotpy.mathutils.colormap import ALL_COLORMAPS
+from plotpy.mathutils.colormap import ALL_COLORMAPS, delete_cmap, get_cmap
 from plotpy.widgets.colormap.manager import ColorMapManager
 from plotpy.widgets.colormap.widget import EditableColormap
 
 
-def test_colormap_manager() -> None:
+@pytest.fixture
+def test_cmap(cmap_name="Kinda Viridis"):
+    cmap = EditableColormap(
+        [QG.QColor(QC.Qt.GlobalColor.blue), QG.QColor(QC.Qt.GlobalColor.yellow)],
+        name=cmap_name,
+    )
+    yield cmap
+
+    delete_cmap(get_cmap(cmap_name))
+
+
+def test_colormap_manager(test_cmap: EditableColormap) -> None:
     """Test the colormap manager widget."""
-    with qt_app_context():
+    with qt_app_context(exec_loop=False):
         red = QG.QColor(QC.Qt.GlobalColor.red)
-        blue = QG.QColor(QC.Qt.GlobalColor.blue)
-        yellow = QG.QColor(QC.Qt.GlobalColor.yellow)
-        cmap = EditableColormap(blue, yellow, name="kinda_viridis")
-        ALL_COLORMAPS["kinda_viridis"] = cmap
-        dlg = ColorMapManager(None, active_colormap="YlGn")
-        dlg.colormap_editor.colormap_widget.add_handle_at_relative_pos(0.5, red)
-        dlg.get_colormap()
-        dlg.colormap_editor.update_colormap_widget()
-        dlg.colormap_editor.update_current_dataset()
-        result = exec_dialog(dlg)
+        cmap_editor = ColorMapManager(None, active_colormap="YlGn")
+        cmap_editor.show()
+
+        with execenv.context(accept_dialogs=True):
+            cmap_editor.save_colormap(test_cmap)
+        cmap_editor.colormap_editor.colormap_widget.add_handle_at_relative_pos(0.5, red)
+        cmap_editor.get_colormap()
+        cmap_editor.colormap_editor.update_colormap_widget()
+        cmap_editor.colormap_editor.update_current_dataset()
+
+        # set the colormap to last one
+        with execenv.context(accept_dialogs=True):
+            cmap_editor.remove_colormap()
+
+        result = exec_dialog(cmap_editor)
         execenv.print("Dialog result:", result)
-        cmap = dlg.get_colormap()
+        cmap = cmap_editor.get_colormap()
         execenv.print("Selected colormap:", None if cmap is None else cmap.name)
+        delete_cmap(test_cmap)
 
 
 if __name__ == "__main__":
-    test_colormap_manager()
+    test_name = "Kinda Viridis"
+    new_colormap = EditableColormap(
+        [QG.QColor(QC.Qt.GlobalColor.blue), QG.QColor(QC.Qt.GlobalColor.yellow)],
+        name=test_name,
+    )
+    test_colormap_manager(new_colormap)
+    delete_cmap(get_cmap(test_name))

plotpy/tests/items/test_curves.py

@@ -12,6 +12,7 @@
 
 from plotpy.builder import make
 from plotpy.tests import vistools as ptv
+from plotpy.tools import CurveStatsTool
 
 
 def test_plot():

plotpy/tests/unit/test_annotation_tools.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pytest
+from guidata.qthelpers import exec_dialog, execenv, qt_app_context
+
+from plotpy.interfaces.items import IBasePlotItem, IShapeItemType
+from plotpy.tests import vistools as ptv
+from plotpy.tests.features.test_auto_curve_image import make_curve_image_legend
+from plotpy.tools import (
+    AnnotatedCircleTool,
+    AnnotatedEllipseTool,
+    AnnotatedObliqueRectangleTool,
+    AnnotatedPointTool,
+    AnnotatedRectangleTool,
+    AnnotatedSegmentTool,
+    AverageCrossSectionTool,
+    CircleTool,
+    CrossSectionTool,
+    EllipseTool,
+    ImageStatsTool,
+    InteractiveTool,
+    LabelTool,
+    ObliqueRectangleTool,
+    PointTool,
+    RectangleTool,
+    SegmentTool,
+    SelectTool,
+    SnapshotTool,
+)
+
+if TYPE_CHECKING:
+    from plotpy.items.image.base import BaseImageItem
+    from plotpy.plot.plotwidget import PlotWindow
+
+from plotpy.tests.unit.utils import drag_mouse, undo_redo
+
+TOOLS: tuple[type[InteractiveTool], ...] = (
+    AnnotatedCircleTool,
+    AnnotatedEllipseTool,
+    AnnotatedObliqueRectangleTool,
+    AnnotatedPointTool,
+    AnnotatedRectangleTool,
+    AnnotatedSegmentTool,
+    AverageCrossSectionTool,
+    CrossSectionTool,
+    SnapshotTool,
+    ImageStatsTool,
+    CircleTool,
+    EllipseTool,
+    ObliqueRectangleTool,
+    PointTool,
+    RectangleTool,
+    SegmentTool,
+    LabelTool,
+)
+
+
+def create_window(tool_classes: tuple[type[InteractiveTool], ...]) -> PlotWindow:
+    """Create a window with the given tools. The plot contains a curve, an image and a
+     legend.
+
+    Args:
+        tool_classes: tools to add to the window.
+
+    Returns:
+        PlotWindow: The window containing the tools.
+    """
+    items = make_curve_image_legend()
+    img: BaseImageItem = items[0]
+    img.set_rotatable(True)
+    img.set_movable(True)
+    win = ptv.show_items(
+        items, wintitle="Unit tests for RectangularActionTools", auto_tools=True
+    )
+
+    for toolklass in tool_classes:
+        _ = win.manager.add_tool(toolklass)
+
+    assert len(tool_classes) > 0
+
+    return win
+
+
+def _test_annotation_tools(tool_classes: tuple[type[InteractiveTool], ...]):
+    """Generic test for annotation tool. Simulates a mouse drag on the plot and checks
+    that the tool is activated and deactivated correctly."""
+    with qt_app_context(exec_loop=False) as qapp:
+        win = create_window(tool_classes)
+        win.show()
+        plot = win.manager.get_plot()
+        default_tool = win.manager.get_default_tool()
+        for tool_class in tool_classes:
+            tool = win.manager.get_tool(tool_class)
+            assert tool is not None
+            tool.activate()
+            x_path = np.linspace(0, 0.5, 100)
+            y_path = np.linspace(0, 0.5, 100)
+            with execenv.context(accept_dialogs=True):
+                drag_mouse(win, qapp, x_path, y_path)
+            if hasattr(tool_class, "SWITCH_TO_DEFAULT_TOOL"):
+                assert win.manager.get_default_tool() == default_tool
+        plot.unselect_all()
+        shape_items: list[IBasePlotItem] = plot.get_items(item_type=IShapeItemType)
+        plot.select_some_items(shape_items)
+        select_tool = win.manager.get_tool(SelectTool)
+        assert select_tool is not None
+        select_tool.activate()
+
+        drag_mouse(win, qapp, np.linspace(0.2, 0.5, 10), np.linspace(0.2, 0.5, 10))
+
+        undo_redo(qapp, win)
+
+        exec_dialog(win)
+
+
+@pytest.mark.parametrize("tool", TOOLS)
+def test_tool(tool: type[InteractiveTool]) -> None:
+    """Test a single tool."""
+    _test_annotation_tools((tool,))
+
+
+def _test_all_tools():
+    """Test all tools."""
+    _test_annotation_tools(TOOLS)
+
+
+if __name__ == "__main__":
+    _test_all_tools()

plotpy/tests/unit/test_cursor_tools.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pytest
+from guidata.qthelpers import exec_dialog, qt_app_context
+
+from plotpy.tests.unit.utils import (
+    create_window,
+    drag_mouse,
+)
+from plotpy.tools import (
+    HCursorTool,
+    HRangeTool,
+    VCursorTool,
+    XCursorTool,
+)
+
+if TYPE_CHECKING:
+    from plotpy.tools.cursor import BaseCursorTool
+
+
+@pytest.mark.parametrize(
+    "cursor_tool", [HCursorTool, VCursorTool, XCursorTool, HRangeTool]
+)
+def test_cursor_tool(cursor_tool: type[BaseCursorTool]):
+    """Test the cursor tools. by simulating a mouse drag and checking if the tool
+    shape is created.
+
+    Args:
+        cursor_tool: Cursor tool class to test.
+    """
+    with qt_app_context(exec_loop=True) as qapp:
+        win, tool = create_window(cursor_tool)
+        win.show()
+        plot = win.manager.get_plot()
+
+        active_tool = win.manager.get_active_tool()
+        assert isinstance(active_tool, cursor_tool)
+        tool_shape_type = type(active_tool.create_shape())
+        assert tool_shape_type not in (type(item) for item in plot.get_items())
+
+        drag_mouse(win, qapp, np.array([0.5, 0.6, 0.7]), np.array([0.5, 0.6, 0.7]))
+        assert tool_shape_type in (type(item) for item in plot.get_items())
+
+        exec_dialog(win)
+
+
+if __name__ == "__main__":
+    for tool in (HCursorTool, VCursorTool, XCursorTool, HRangeTool):
+        test_cursor_tool(tool)