Merge pull request #156 from DeepLabCut/cy/expand-writer-tests

Expand test coverage (writer and widgets)

Author: C-Achard

setup.cfg

@@ -56,6 +56,7 @@ napari.manifest =
 
 [options.extras_require]
 testing =
+    Pillow
     pytest
     pytest-cov
     pytest-qt

src/napari_deeplabcut/_reader.py

@@ -156,11 +156,16 @@ def _populate_metadata(
 
 def _load_superkeypoints_diagram(super_animal: str):
     path = str(Path(__file__).parent / "assets" / f"{super_animal}.jpg")
-    return imread(path), {"root": ""}, "images"
+    try:
+        return imread(path), {"root": ""}, "images"
+    except Exception as e:
+        raise FileNotFoundError(f"Superkeypoints diagram not found for {super_animal}.") from e
 
 
 def _load_superkeypoints(super_animal: str):
     path = str(Path(__file__).parent / "assets" / f"{super_animal}.json")
+    if not Path(path).is_file():
+        raise FileNotFoundError(f"Superkeypoints JSON file not found for {super_animal}.")
     with open(path) as f:
         return json.load(f)
 

src/napari_deeplabcut/_tests/conftest.py

@@ -1,9 +1,12 @@
+import json
 import os
+from pathlib import Path
 
 import cv2
 import numpy as np
 import pandas as pd
 import pytest
+from PIL import Image
 from qtpy.QtWidgets import QDockWidget
 from skimage.io import imsave
 
@@ -151,3 +154,78 @@ def video_path(tmp_path_factory):
         writer.write(frame)
     writer.release()
     return output_path
+
+
+@pytest.fixture
+def superkeypoints_assets(tmp_path, monkeypatch):
+    """
+    Create a fake module dir with the expected assets layout:
+
+        module_dir/_reader_fake.py       -> patched as __file__
+        module_dir/assets/fake.json
+        module_dir/assets/fake.jpg
+
+    This mirrors the code under test:
+      Path(__file__).parent / "assets" / f"{super_animal}.json|.jpg"
+    """
+    module_dir = tmp_path / "module"
+    assets_dir = module_dir / "assets"
+    assets_dir.mkdir(parents=True)
+
+    super_animal = "fake"
+    data = {
+        "SK1": [10.0, 20.0],
+        "SK2": [40.0, 60.0],
+    }
+
+    # JSON with superkeypoints coordinates
+    (assets_dir / f"{super_animal}.json").write_text(json.dumps(data))
+
+    # Small 10x10 RGB diagram
+    Image.new("RGB", (10, 10), "white").save(assets_dir / f"{super_animal}.jpg")
+
+    # Patch the module's __file__ so that Path(__file__).parent == module_dir
+    fake_module_file = module_dir / "_reader_fake.py"
+    fake_module_file.write_text("# fake")
+    monkeypatch.setattr("napari_deeplabcut._reader.__file__", str(fake_module_file))
+
+    return {
+        "module_dir": module_dir,
+        "assets_dir": assets_dir,
+        "super_animal": super_animal,
+        "data": data,
+    }
+
+
+@pytest.fixture
+def mapped_points(points, superkeypoints_assets, config_path):
+    """
+    Return a DLC Points layer that is ready for _map_keypoints():
+      - metadata['project'] is set (so the widget can write config.yaml)
+      - metadata['tables'] contains a mapping for two real bodyparts -> SK1/SK2
+      - at least two rows have coordinates exactly on the SK1/SK2 positions
+        and their labels are set to those bodyparts, guaranteeing a neighbor match.
+    """
+    layer = points  # DLC layer created via viewer.open(..., plugin="napari-deeplabcut")
+    super_animal = superkeypoints_assets["super_animal"]
+    superkpts = superkeypoints_assets["data"]
+
+    # Required by _map_keypoints to locate and write config.yaml
+    # NOTE: This relies on config_path pointing to a file directly under the
+    # project directory, so that Path(config_path).parent is the project root.
+    layer.metadata["project"] = str(Path(config_path).parent)
+    header = layer.metadata["header"]
+    bp1, bp2 = header.bodyparts[:2]
+
+    # Inject a conversion table into metadata
+    layer.metadata["tables"] = {super_animal: {bp1: "SK1", bp2: "SK2"}}
+
+    # Ensure _map_keypoints finds matches:
+    # Put the first two rows exactly on SK1/SK2 and set their labels accordingly.
+    layer.data[0, 1:] = np.array(superkpts["SK1"], dtype=float)
+    layer.properties["label"][0] = bp1
+
+    layer.data[1, 1:] = np.array(superkpts["SK2"], dtype=float)
+    layer.properties["label"][1] = bp2
+
+    return layer, super_animal, bp1, bp2

src/napari_deeplabcut/_tests/test_reader.py

@@ -1,6 +1,7 @@
 import numpy as np
 import pandas as pd
 import pytest
+from PIL import Image
 from skimage.io import imsave
 
 from napari_deeplabcut import _reader
@@ -110,3 +111,68 @@ def test_read_video(video_path):
     assert dict_["metadata"].get("root")
     assert array.shape[0] == 5
     assert array[0].compute().shape == (50, 50, 3)
+
+
+@pytest.mark.parametrize(
+    "exists",
+    [
+        True,
+        False,
+    ],
+)
+def test_load_superkeypoints(monkeypatch, tmp_path, exists):
+    """Test loading of superkeypoints JSON with and without the file present."""
+    module_dir = tmp_path / "module"
+    assets_dir = module_dir / "assets"
+    assets_dir.mkdir(parents=True)
+
+    super_animal = "fake"
+    json_path = assets_dir / f"{super_animal}.json"
+
+    if exists:
+        json_path.write_text('{"SK1": [1, 2]}')
+
+    # Patch module __file__
+    fake_file = module_dir / "_reader_fake.py"
+    fake_file.write_text("# fake module")
+    monkeypatch.setattr("napari_deeplabcut._reader.__file__", str(fake_file))
+
+    if exists:
+        assert _reader._load_superkeypoints(super_animal) == {"SK1": [1, 2]}
+    else:
+        with pytest.raises(FileNotFoundError):
+            _reader._load_superkeypoints(super_animal)
+
+
+@pytest.mark.parametrize(
+    "exists",
+    [
+        True,
+        False,
+    ],
+)
+def test_load_superkeypoints_diagram(monkeypatch, tmp_path, exists):
+    """Test loading of superkeypoints diagram with and without the file present."""
+    module_dir = tmp_path / "module"
+    assets_dir = module_dir / "assets"
+    assets_dir.mkdir(parents=True)
+
+    super_animal = "fake"
+    jpg_path = assets_dir / f"{super_animal}.jpg"
+
+    if exists:
+        Image.new("RGB", (10, 10), "white").save(jpg_path)
+
+    # Patch module __file__
+    fake_file = module_dir / "_reader_fake.py"
+    fake_file.write_text("# fake")
+    monkeypatch.setattr("napari_deeplabcut._reader.__file__", str(fake_file))
+
+    if exists:
+        array, meta, layer_type = _reader._load_superkeypoints_diagram(super_animal)
+        assert layer_type == "images"
+        assert meta == {"root": ""}
+        assert tuple(array.shape[-3:-1]) == (10, 10)
+    else:
+        with pytest.raises(FileNotFoundError):
+            _reader._load_superkeypoints_diagram(super_animal)

src/napari_deeplabcut/_tests/test_widgets.py

@@ -3,6 +3,8 @@
 
 import numpy as np
 import pytest
+import yaml
+from qtpy.QtSvgWidgets import QSvgWidget
 from vispy import keys
 
 from napari_deeplabcut import _widgets
@@ -310,3 +312,65 @@ def add_dock_widget(self, *args, **kwargs):
 
     # Docking failed → remains undocked
     assert controls._mpl_docked is False
+
+
+def test_display_shortcuts_dialog(viewer, qtbot):
+    """Ensure that the Shortcuts dialog can be created and shown without errors."""
+    controls = _widgets.KeypointControls(viewer)
+    qtbot.add_widget(controls)
+
+    # Create the dialog directly
+    dlg = _widgets.Shortcuts(controls)
+    qtbot.add_widget(dlg)
+
+    # Show it non-modally
+    dlg.show()
+    qtbot.waitExposed(dlg)
+
+    # Verify it is visible
+    assert dlg.isVisible()
+
+    # Ensure the SVG widget is present
+    found_svg = False
+    for child in dlg.children():
+        if isinstance(child, QSvgWidget):
+            found_svg = True
+            break
+
+    assert found_svg, "Shortcuts dialog should contain a QSvgWidget with the shortcuts image."
+
+
+# NOTE SuperAnimal keypoints functionality and testing may need an overhaul in the future:
+# these tests currently exercise only a narrow "everything fine" path and rely on specific metadata
+# layout and SuperAnimal conversion-table conventions, which makes them susceptible to API changes
+def test_widget_load_superkeypoints_diagram(viewer, qtbot, points, superkeypoints_assets):
+    controls = _widgets.KeypointControls(viewer)
+    qtbot.add_widget(controls)
+
+    # Inject conversion table into the existing Points layer
+    layer = points
+    super_animal = superkeypoints_assets["super_animal"]
+    layer.metadata["tables"] = {super_animal: {"kp1": "SK1", "kp2": "SK2"}}
+
+    n_layers_before = len(viewer.layers)
+    controls.load_superkeypoints_diagram()
+
+    assert len(viewer.layers) == n_layers_before + 1
+    assert list(layer.properties["label"]) == ["kp1", "kp2"]
+    assert controls._keypoint_mapping_button.text() == "Map keypoints"
+
+
+def test_widget_map_keypoints_writes_to_config(viewer, qtbot, mapped_points, config_path):
+    controls = _widgets.KeypointControls(viewer)
+    qtbot.add_widget(controls)
+
+    _, super_animal, bp1, bp2 = mapped_points
+    controls._map_keypoints(super_animal)
+
+    with open(config_path, encoding="utf-8") as fh:
+        cfg = yaml.safe_load(fh)
+    assert "SuperAnimalConversionTables" in cfg
+    assert cfg["SuperAnimalConversionTables"][super_animal] == {
+        bp1: "SK1",
+        bp2: "SK2",
+    }