Merge pull request #2080 from wkentaro/test/prefer-e2e-coverage

test: prefer end-to-end coverage over internal-helper unit tests

Author: wkentaro

tests/e2e/annotation_test.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Literal
 
 import osam.types._blob
 import pytest
@@ -10,6 +9,8 @@
 from PyQt5.QtCore import QTimer
 from pytestqt.qtbot import QtBot
 
+from labelme._automation._types import AiOutputFormat
+
 from ..conftest import assert_labelfile_sanity
 from ..conftest import close_or_pause
 from .conftest import MainWinFactory
@@ -103,6 +104,33 @@
             "mask",
             id="ai_points-mask",
         ),
+        pytest.param(
+            "ai_points_to_shape",
+            [],
+            (0.5, 0.5),
+            Qt.ControlModifier,
+            2,
+            "rectangle",
+            id="ai_points-rectangle",
+        ),
+        pytest.param(
+            "ai_points_to_shape",
+            [],
+            (0.5, 0.5),
+            Qt.ControlModifier,
+            2,
+            "circle",
+            id="ai_points-circle",
+        ),
+        pytest.param(
+            "ai_points_to_shape",
+            [],
+            (0.5, 0.5),
+            Qt.ControlModifier,
+            4,
+            "oriented_rectangle",
+            id="ai_points-oriented_rectangle",
+        ),
         pytest.param(
             "ai_box_to_shape",
             [(0.3, 0.3)],
@@ -121,6 +149,24 @@
             "mask",
             id="ai_box-mask",
         ),
+        pytest.param(
+            "ai_box_to_shape",
+            [(0.3, 0.3)],
+            (0.7, 0.7),
+            Qt.NoModifier,
+            2,
+            "rectangle",
+            id="ai_box-rectangle",
+        ),
+        pytest.param(
+            "ai_box_to_shape",
+            [(0.3, 0.3)],
+            (0.7, 0.7),
+            Qt.NoModifier,
+            2,
+            "circle",
+            id="ai_box-circle",
+        ),
         pytest.param(
             "ai_box_to_shape",
             [(0.3, 0.3)],
@@ -143,7 +189,7 @@ def test_annotate_shape_types(
     finalize_click: tuple[float, float],
     finalize_modifier: Qt.KeyboardModifier,
     expected_num_points: int | None,
-    ai_output_format: Literal["polygon", "mask", "oriented_rectangle"] | None,
+    ai_output_format: AiOutputFormat | None,
 ) -> None:
     expected_shape_type = ai_output_format if ai_output_format else create_mode
 

tests/e2e/canvas_interaction_test.py

@@ -1,14 +1,19 @@
 from __future__ import annotations
 
+import base64
+import json
 from pathlib import Path
 from typing import Final
 
+import numpy as np
+import PIL.Image
 import pytest
 from PyQt5.QtCore import QPointF
 from PyQt5.QtCore import Qt
 from pytestqt.qtbot import QtBot
 
 from labelme import _shape
+from labelme import utils
 from labelme._shape import Shape
 from labelme.app import MainWindow
 from labelme.widgets.canvas import Canvas
@@ -17,11 +22,14 @@
 
 from ..conftest import assert_labelfile_sanity
 from ..conftest import close_or_pause
+from .conftest import MainWinFactory
 from .conftest import click_canvas_fraction
 from .conftest import drag_canvas
+from .conftest import hover_widget_pos
 from .conftest import image_to_widget_pos
 from .conftest import schedule_on_dialog
 from .conftest import select_shape
+from .conftest import show_window_and_wait_for_imagedata
 from .conftest import submit_label_dialog
 
 _TEST_FILE_NAME: Final[str] = "annotated/2011_000003.json"
@@ -602,3 +610,134 @@ def test_remove_point_blocked_at_minimum(
 
     _save_and_check(win=raw_win, tmp_path=tmp_path)
     close_or_pause(qtbot=qtbot, widget=raw_win, pause=pause)
+
+
+def _click_to_select(qtbot: QtBot, canvas: Canvas, image_pos: QPointF) -> None:
+    pos = image_to_widget_pos(canvas=canvas, image_pos=image_pos)
+    hover_widget_pos(qtbot=qtbot, canvas=canvas, pos=pos)
+    qtbot.mouseClick(canvas, Qt.LeftButton, pos=pos)
+    qtbot.wait(50)
+
+
+@pytest.mark.gui
+def test_select_point_shape_by_click(
+    qtbot: QtBot,
+    raw_win: MainWindow,
+    pause: bool,
+) -> None:
+    canvas = raw_win._canvas_widgets.canvas
+    raw_win._switch_canvas_mode(edit=False, create_mode="point")
+    qtbot.wait(50)
+
+    submit_label_dialog(qtbot=qtbot, label_dialog=raw_win._label_dialog, label="pt")
+    click_canvas_fraction(qtbot=qtbot, canvas=canvas, xy=(0.5, 0.5))
+
+    shape = _wait_for_shape(qtbot=qtbot, canvas=canvas, label="pt")
+    assert shape.shape_type == "point"
+
+    raw_win._switch_canvas_mode(edit=True)
+    qtbot.wait(50)
+
+    _click_to_select(qtbot=qtbot, canvas=canvas, image_pos=QPointF(shape.points[0]))
+
+    assert shape in canvas.selected_shapes
+
+    close_or_pause(qtbot=qtbot, widget=raw_win, pause=pause)
+
+
+@pytest.mark.gui
+def test_right_click_on_shape_opens_context_menu(
+    qtbot: QtBot,
+    annotated_win: MainWindow,
+    monkeypatch: pytest.MonkeyPatch,
+    pause: bool,
+) -> None:
+    canvas = annotated_win._canvas_widgets.canvas
+    # No prior right-drag has populated `_selected_shapes_copy`, so the bare
+    # right-click should open menus[0] (the no-clipboard variant). Stubbing
+    # both exec_ methods catches a regression that would route to menus[1].
+    menu_opened: list[int] = []
+    monkeypatch.setattr(
+        canvas.menus[0],
+        "exec_",
+        lambda *args, **kwargs: menu_opened.append(0) or None,
+    )
+    monkeypatch.setattr(
+        canvas.menus[1],
+        "exec_",
+        lambda *args, **kwargs: menu_opened.append(1) or None,
+    )
+
+    bounds_center = _shape.bounds(shape=canvas.shapes[_SHAPE_INDEX]).center()
+    pos = image_to_widget_pos(canvas=canvas, image_pos=bounds_center)
+    qtbot.mouseMove(canvas, pos=pos)
+    qtbot.wait(50)
+    qtbot.mouseClick(canvas, Qt.RightButton, pos=pos)
+    qtbot.wait(50)
+
+    assert menu_opened == [0]
+
+    close_or_pause(qtbot=qtbot, widget=annotated_win, pause=pause)
+
+
+@pytest.mark.gui
+def test_select_mask_shape_by_click(
+    main_win: MainWinFactory,
+    qtbot: QtBot,
+    data_path: Path,
+    tmp_path: Path,
+    pause: bool,
+) -> None:
+    # Mask cells are indexed pixel-for-pixel from points[0]; clicking inside
+    # the True region must land on a True cell to exercise the mask branch
+    # of `_shape.contains_point`.
+    mask_arr = np.zeros((40, 40), dtype=np.uint8)
+    mask_arr[10:30, 10:30] = 1
+    mask_b64 = utils.img_arr_to_b64(mask_arr)
+
+    raw_image_path = data_path / "raw/2011_000003.jpg"
+    img_b64 = base64.b64encode(raw_image_path.read_bytes()).decode("utf-8")
+    image_width, image_height = PIL.Image.open(raw_image_path).size
+
+    fixture_json = tmp_path / "mask_fixture.json"
+    fixture_json.write_text(
+        json.dumps(
+            {
+                "version": "6.0.0",
+                "flags": {},
+                "shapes": [
+                    {
+                        "label": "mask_shape",
+                        "points": [[100.0, 100.0], [139.0, 139.0]],
+                        "group_id": None,
+                        "description": "",
+                        "shape_type": "mask",
+                        "flags": {},
+                        "mask": mask_b64,
+                    }
+                ],
+                "imagePath": raw_image_path.name,
+                "imageData": img_b64,
+                "imageHeight": image_height,
+                "imageWidth": image_width,
+            }
+        )
+    )
+
+    win = main_win(
+        file_or_dir=str(fixture_json),
+        config_overrides={"with_image_data": True},
+    )
+    show_window_and_wait_for_imagedata(qtbot=qtbot, win=win)
+    canvas = win._canvas_widgets.canvas
+
+    qtbot.waitUntil(lambda: any(s.label == "mask_shape" for s in canvas.shapes))
+    shape = next(s for s in canvas.shapes if s.label == "mask_shape")
+
+    # True region in image coords: rows/cols 110..129 (mask[10:30,10:30] +
+    # origin (100,100)). Click well inside that block.
+    _click_to_select(qtbot=qtbot, canvas=canvas, image_pos=QPointF(120.0, 120.0))
+
+    assert shape in canvas.selected_shapes
+
+    close_or_pause(qtbot=qtbot, widget=win, pause=pause)

tests/e2e/conftest.py

@@ -136,6 +136,17 @@ def create(
             pass
 
 
+def hover_widget_pos(qtbot: QtBot, canvas: Canvas, pos: QPoint) -> None:
+    # The offscreen Qt platform dedupes mouseMove events that match the
+    # current cursor position, which suppresses hover-state refresh after a
+    # click that landed on the same pixel. Nudging to (0, 0) first guarantees
+    # the second move is treated as fresh.
+    qtbot.mouseMove(canvas, pos=QPoint(0, 0))
+    qtbot.wait(50)
+    qtbot.mouseMove(canvas, pos=pos)
+    qtbot.wait(50)
+
+
 def click_canvas_fraction(
     qtbot: QtBot,
     canvas: Canvas,