doc

Author: vld-codra

plotpy/tests/unit/test_aspect_ratio_tool.py

@@ -9,6 +9,7 @@
 
 
 def test_aspect_ratio_tool():
+    """Test the aspect ratio tool."""
     with qt_app_context(exec_loop=False):
         win, tool = create_window(AspectRatioTool, active_item_type=IImageItemType)
         plot = win.manager.get_plot()

plotpy/tests/unit/test_display_coords_tool.py

@@ -9,13 +9,15 @@
 
 
 def test_display_coords_on_curve():
+    """Test display coordinates tool on a curve."""
     with qt_app_context(exec_loop=False) as qapp:
         win, tool = create_window(DisplayCoordsTool)
         drag_mouse(win, qapp, np.array([0.5]), np.array([0.5]), click=False)
         drag_mouse(win, qapp, np.array([0.5]), np.array([0.5]), click=True)
 
 
 def test_display_coords_on_image():
+    """Test display coordinates tool on an image."""
     with qt_app_context(exec_loop=False) as qapp:
         win, tool = create_window(DisplayCoordsTool, active_item_type=IImageItemType)
         drag_mouse(win, qapp, np.array([0.5]), np.array([0.5]), click=False)

plotpy/tests/unit/test_multiline_tools.py

@@ -14,6 +14,7 @@
 
 
 def test_free_form_tool():
+    """Test the free form tool."""
     corners = np.array(((0.1, 0.1), (0.1, 0.8), (0.8, 0.8), (0.8, 0.1)))
     with qt_app_context(exec_loop=False) as qapp:
         win, tool = create_window(FreeFormTool)
@@ -30,6 +31,7 @@ def test_free_form_tool():
 
 
 def test_multiline_tool():
+    """Test the multi line tool."""
     n = 100
     t = np.linspace(0, np.pi * 10, n)
 

plotpy/tests/unit/test_oblique_cross_section_tool.py

@@ -10,6 +10,7 @@
 
 
 def test_oblique_cross_section():
+    """Test the oblique cross section tool."""
     with qt_app_context(exec_loop=False) as qapp:
         win, tool = create_window(
             ObliqueCrossSectionTool,

plotpy/tests/unit/test_point_tools.py

@@ -22,6 +22,7 @@
 
 
 def test_free_select_point_tool():
+    """Test the free select point tool."""
     with qt_app_context(exec_loop=False) as qapp:
         win, tool = create_window(SelectPointTool)
         mouse_event_at_relative_plot_pos(
@@ -35,20 +36,29 @@ def test_free_select_point_tool():
 
 
 def test_contrained_select_point_tool():
+    """Test the constrained select point tool contrained to a CurveItem."""
     with qt_app_context(exec_loop=False) as qapp:
         win, tool = create_window(SelectPointTool)
         tool.on_active_item = True
+
         mouse_event_at_relative_plot_pos(
             win,
             qapp,
             (0.5, 0.5),
             CLICK,
         )
-        assert tool.get_coordinates() is not None
+        coor = tool.get_coordinates()
+        curve_item: CurveItem = win.manager.get_plot().get_active_item()  # type: ignore
+        arr_x, arr_y = curve_item.get_data()
+        assert coor is not None
+
+        x, y = coor
+        assert np.where(arr_x == x)[0] == np.where(arr_y == y)[0]
         exec_dialog(win)
 
 
 def test_select_points_tool():
+    """Test the select points tool constrained to a CurveItem."""
     with qt_app_context(exec_loop=False) as qapp:
         win, tool = create_window(tool_class=SelectPointsTool)
         mod = QC.Qt.KeyboardModifier.ControlModifier
@@ -69,10 +79,18 @@ def test_select_points_tool():
         mouse_event_at_relative_plot_pos(win, qapp, (0.1, 0.1), CLICK)
         assert len(tool.get_coordinates() or ()) == 1
 
+        coor = tool.get_coordinates()
+        assert coor is not None
+        x, y = coor[0]
+        curve_item: CurveItem = win.manager.get_plot().get_active_item()  # type: ignore
+        arr_x, arr_y = curve_item.get_data()
+        assert np.where(arr_x == x)[0] == np.where(arr_y == y)[0]
+
         exec_dialog(win)
 
 
 def test_edit_point_tool():
+    """Test the edit point tool for a CurveItem."""
     with qt_app_context(exec_loop=False) as qapp:
         win, tool = create_window(EditPointTool)
         curve_item: CurveItem = win.manager.get_plot().get_active_item()  # type: ignore
@@ -105,9 +123,13 @@ def test_edit_point_tool():
             assert x == x_arr[i]
             assert y == y_arr[i]
 
-        tool.get_arrays()
-        tool.get_initial_arrays()
+        x_arr, y_arr = tool.get_arrays()
+        assert x_arr is not None and y_arr is not None
+
+        x_arr, y_arr = tool.get_initial_arrays()
+        assert x_arr is not None and y_arr is not None
 
+        # Reset the arrays and deletes the changes
         keyboard_event(
             win, qapp, QC.Qt.Key.Key_Z, QC.Qt.KeyboardModifier.ControlModifier
         )

plotpy/tests/unit/test_rect_zoom.py

@@ -14,6 +14,16 @@
 def zoom(
     x_path: np.ndarray, y_path: np.ndarray, compare: Callable[[float, float], bool]
 ):
+    """Zoom in or out on a plot by sumilating a mouse drag along a defined path.
+
+    Args:
+        x_path: The x relative plot coordinates of the path to simulate the mouse
+         drag along.
+        y_path: The y relative plot coordinates of the path to simulate the mouse
+         drag along.
+        compare: Comparison function to compare the initial and final axis limits to
+         check if the zoom worked as expected.
+    """
     with qt_app_context(exec_loop=False) as qapp:
         win, tool = create_window(RectZoomTool, active_item_type=ICurveItemType)
         plot = win.manager.get_plot()
@@ -41,12 +51,14 @@ def zoom(
 
 
 def test_rect_zoom_tool():
+    """Test the rectangular zoom tool."""
     x_path = linspace(0, 0.5, 100)
     y_path = linspace(0, 0.5, 100)
     zoom(x_path, y_path, lambda og, final: final < og)
 
 
 def test_rect_unzoom_tool():
+    """Test the rectangular zoom tool to unzoom."""
     x_path = linspace(-0.5, 1.5, 100)
     y_path = linspace(-0.5, 1.5, 100)
     zoom(x_path, y_path, lambda og, final: abs(final) > abs(og))

plotpy/tests/unit/test_shape_tools.py

@@ -57,6 +57,15 @@
 
 
 def create_window(tool_classes: tuple[type[RectangularActionTool], ...]) -> 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()
     win = ptv.show_items(
         items, wintitle="Unit tests for RectangularActionTools", auto_tools=True
@@ -66,18 +75,13 @@ def create_window(tool_classes: tuple[type[RectangularActionTool], ...]) -> Plot
         _ = win.manager.add_tool(toolklass)
 
     assert len(tool_classes) > 0
-    # win.manager.set_default_tool(tool)
 
     return win
 
 
-def use_tool(win: PlotWindow, tool_class: type[RectangularActionTool]):
-    filter_ = win.manager.get_plot().filter
-    if (tool := win.manager.get_tool(tool_class)) is not None:
-        tool.end_rect(filter_, P0, P1)
-
-
 def _test_annotation_tools(tool_classes: tuple[type[RectangularActionTool], ...]):
+    """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)
         default_tool = win.manager.get_default_tool()
@@ -94,66 +98,82 @@ def _test_annotation_tools(tool_classes: tuple[type[RectangularActionTool], ...]
 
 
 def test_annotated_circle_tool():
+    """Test the annotated circle tool."""
     _test_annotation_tools((AnnotatedCircleTool,))
 
 
 def test_annotated_ellipse_tool():
+    """Test the annotated ellipse tool."""
     _test_annotation_tools((AnnotatedEllipseTool,))
 
 
 def test_annotated_oblique_rectangle_tool():
+    """Test the annotated oblique rectangle tool."""
     _test_annotation_tools((AnnotatedObliqueRectangleTool,))
 
 
 def test_annotated_point_tool():
+    """Test the annotated point tool."""
     _test_annotation_tools((AnnotatedPointTool,))
 
 
 def test_annotated_rectangle_tool():
+    """Test the annotated rectangle tool."""
     _test_annotation_tools((AnnotatedRectangleTool,))
 
 
 def test_annotated_segment_tool():
+    """Test the annotated segment tool."""
     _test_annotation_tools((AnnotatedSegmentTool,))
 
 
 def test_avg_cross_section_tool():
+    """Test the average cross section tool."""
     _test_annotation_tools((AverageCrossSectionTool,))
 
 
 def test_cross_section_tool():
+    """Test the cross section tool."""
     _test_annotation_tools((CrossSectionTool,))
 
 
 def test_snapshot_tool():
+    """Test the snapshot tool."""
     _test_annotation_tools((SnapshotTool,))
 
 
 def test_image_stats_tool():
+    """Test the image stats tool."""
     _test_annotation_tools((ImageStatsTool,))
 
 
 def test_circle_tool():
+    """Test the circle tool."""
     _test_annotation_tools((CircleTool,))
 
 
 def test_ellipse_tool():
+    """Test the ellipse tool."""
     _test_annotation_tools((EllipseTool,))
 
 
 def test_oblique_rectangle_tool():
+    """Test the oblique rectangle tool."""
     _test_annotation_tools((ObliqueRectangleTool,))
 
 
 def test_point_tool():
+    """Test the point tool."""
     _test_annotation_tools((PointTool,))
 
 
 def test_rectangle_tool():
+    """Test the rectangle tool."""
     _test_annotation_tools((RectangleTool,))
 
 
 def test_segment_tool():
+    """Test the segment tool."""
     _test_annotation_tools((SegmentTool,))
 
 

plotpy/tests/unit/utils.py

@@ -102,6 +102,17 @@ def drag_mouse(
     mod=QC.Qt.KeyboardModifier.NoModifier,
     click=True,
 ) -> None:
+    """Simulates a mouse drag on the plot.
+
+    Args:
+        win: window containing the plot
+        qapp: QApplication instance
+        x_path: relative x plot coordinates of the path to simulate the mouse drag along
+        y_path: relative y plot coordinates of the path to simulate the mouse drag along
+        mod: keyboard modifier. Defaults to QC.Qt.KeyboardModifier.NoModifier.
+        click: Whether a click must be simulated (mouse hold -> drag -> mouse release).
+         Defaults to True.
+    """
     x0, y0 = x_path[0], y_path[0]
     xn, yn = x_path[-1], y_path[-1]
     press = (QC.QEvent.Type.MouseButtonPress,)
@@ -121,7 +132,18 @@ def create_window(
     active_item_type: type[IItemType] = ICurveItemType,
     panels: list[type[PanelWidget]] | None = None,
 ) -> tuple[PlotWindow, ToolT]:
+    """Create a window with the given tool. The plot contains a curve, an image and a
+     legend.
 
+    Args:
+        tool_class: tool class to add to the window.
+        active_item_type: Type of Item to set to active (curve or image).
+         Defaults to ICurveItemType.
+        panels: PanelWidget classes to add. Defaults to None.
+
+    Returns:
+        The window containing the activated tool and the tool instance itself.
+    """
     items: list[CurveItem | BaseImageItem] = make_curve_image_legend()
     win = ptv.show_items(items, wintitle="Unit test plot", auto_tools=False)
     plot = win.manager.get_plot()