test(data): add unit tests the mesh generator + add slow config

Author: MattTheCuber

.github/workflows/test.yml

@@ -22,6 +22,8 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v6
+        with:
+          submodules: true
 
       - name: Set up Python ${{ matrix.python-version }}
         uses: astral-sh/setup-uv@v7
@@ -32,4 +34,4 @@ jobs:
         run: uv sync --all-extras
 
       - name: Run Tests
-        run: uv run pytest
+        run: uv run pytest --slow

.vscode/settings.json

@@ -1,5 +1,5 @@
 {
-  "python.testing.pytestArgs": ["edge_mender"],
+  "python.testing.pytestArgs": ["edge_mender", "--slow"],
   "python.testing.unittestEnabled": false,
   "python.testing.pytestEnabled": true
 }

conftest.py

@@ -0,0 +1,32 @@
+"""Configuration for pytest."""
+
+import pytest
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    """Add command line options for pytest."""
+    parser.addoption(
+        "--slow",
+        action="store_true",
+        default=False,
+        help="Run long-running tests",
+    )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    """Configure pytest with custom markers."""
+    config.addinivalue_line("markers", "slow: mark test as slow to run")
+
+
+def pytest_collection_modifyitems(
+    config: pytest.Config,
+    items: list[pytest.Item],
+) -> None:
+    """Modify collected test items to skip slow tests unless --slow is given."""
+    if config.getoption("--slow"):
+        # --slow given in cli: do not skip slow tests
+        return
+    skip_slow = pytest.mark.skip(reason="need --slow option to run")
+    for item in items:
+        if "slow" in item.keywords:
+            item.add_marker(skip_slow)

edge_mender/mesh_generator.py

@@ -1,3 +1,5 @@
+"""Module for generating meshes from 3D numpy arrays using different algorithms."""
+
 import sys
 from pathlib import Path
 
@@ -14,18 +16,20 @@
 
 
 class MeshGenerator:
+    """Class for generating meshes from 3D numpy arrays using different algorithms."""
+
     @staticmethod
     def to_mesh_cuberille(data: NDArray) -> trimesh.Trimesh:
         """Convert a Numpy array to a mesh using Cuberille from ITK."""
+        # Implicitly load ITKCommon module
         if "itk.CuberillePython" not in sys.modules:
-            print("Loading ITK Cuberille module. This will take a while...")
+            print("Loading ITK Cuberille module. This will take a while...")  # noqa: T201
 
-            itk.Image  # implicitly load ITKCommon module
-            from itk.CuberillePython import cuberille_image_to_mesh_filter
+            itk.Image  # pyright: ignore[reportAttributeAccessIssue]  # noqa: B018
 
-            print("ITK Cuberille module loaded.")
+            print("ITK Cuberille module loaded.")  # noqa: T201
 
-        from itk.CuberillePython import cuberille_image_to_mesh_filter
+        from itk.CuberillePython import cuberille_image_to_mesh_filter  # noqa: PLC0415
 
         # Generate the mesh using ITK's Cuberille implementation
         itk_mesh: itk.itkMeshBasePython.itkMeshD3 = cuberille_image_to_mesh_filter(
@@ -60,10 +64,11 @@ def to_mesh_cuberille(data: NDArray) -> trimesh.Trimesh:
     @staticmethod
     def to_mesh_surface_nets(data: NDArray) -> trimesh.Trimesh:
         """Convert a Numpy array to a mesh using Surface Nets from PyVista/VTK."""
-        pv_data: pv.ImageData = pv.wrap(data)
+        pv_data: pv.ImageData = pv.wrap(data)  # pyright: ignore[reportAssignmentType]
         mesh = pv_data.contour_labels(output_mesh_type="triangles", smoothing=False)
         faces = mesh.faces.reshape((mesh.n_cells, 4))[:, 1:]
         mesh = trimesh.Trimesh(mesh.points, faces)
+        # TODO: This shouldn't be needed after https://gitlab.kitware.com/vtk/vtk/-/issues/19156
         mesh.fix_normals()
         if mesh.volume < 0:
             mesh.invert()
@@ -73,8 +78,8 @@ def to_mesh_surface_nets(data: NDArray) -> trimesh.Trimesh:
     def to_mesh_dual_contouring(data: NDArray) -> trimesh.Trimesh:
         """Convert a Numpy array to a mesh using Dual Contouring from Daniel Wilmes."""
         # Add the submodule to the path so we can import it
-        project_root = Path(__file__).parent / "edge_mender" / "Dual_Contouring_Voxel"
-        if not project_root.exists():
+        project_root = Path(__file__).parent / "Dual_Contouring_Voxel"
+        if not project_root.exists():  # pragma: no cover
             missing_module_error = (
                 "Could not find Dual Contouring module. "
                 "Perhaps you forgot to run `git submodule update --init`?"
@@ -83,20 +88,15 @@ def to_mesh_dual_contouring(data: NDArray) -> trimesh.Trimesh:
         sys.path.append(str(project_root))
 
         # Remove the app code from the Dual Contouring module
-        p = (
-            Path(__file__).parent
-            / "edge_mender"
-            / "Dual_Contouring_Voxel"
-            / "Dual_Contouring.py"
-        )
-        lines = p.read_text().splitlines()
+        dual_contouring_py = project_root / "Dual_Contouring.py"
+        lines = dual_contouring_py.read_text().splitlines()
         try:
             idx = next(i for i, line in enumerate(lines) if line == "app = myapp()")
         except StopIteration:
             idx = None
-        if idx is not None:
+        if idx is not None:  # pragma: no cover
             new_content = "\n".join(lines[:idx])
-            p.write_text(new_content + ("\n" if new_content else ""))
+            dual_contouring_py.write_text(new_content + ("\n" if new_content else ""))
 
         from edge_mender.Dual_Contouring_Voxel.Dual_Contouring import (  # noqa: PLC0415
             dual_contouring,

edge_mender/tests/test_data_factory.py

@@ -1,3 +1,5 @@
+"""Test the DataFactory class."""
+
 import numpy as np
 import pytest
 from numpy.typing import NDArray

edge_mender/tests/test_mesh_generator.py

@@ -0,0 +1,83 @@
+"""Test the DataFactory class."""
+
+import pytest
+from numpy.typing import NDArray
+
+from edge_mender.data_factory import DataFactory
+from edge_mender.mesh_generator import MeshGenerator
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize(
+    "data",
+    [
+        DataFactory.simple_extrusion(),
+        DataFactory.double_extrusion(),
+        DataFactory.triple_extrusion(),
+        DataFactory.stairs(),
+        DataFactory.ceiling(),
+        # These two cases fail due to the Cuberille implementation in ITK
+        # DataFactory.double_tower_ceiling(.),
+        DataFactory.hanging_points(),
+        # DataFactory.checkerboard(.),
+        DataFactory.hole(),
+        DataFactory.kill_you(),
+        DataFactory.random(size=8, seed=0),
+    ],
+)
+def test_to_mesh_cuberille(data: NDArray) -> None:
+    """Test MeshGenerator.to_mesh_cuberille."""
+    mesh = MeshGenerator.to_mesh_cuberille(data)
+    assert len(mesh.vertices) > 0
+    assert len(mesh.faces) > 0
+    assert mesh.volume > 0
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        DataFactory.simple_extrusion(),
+        DataFactory.double_extrusion(),
+        DataFactory.triple_extrusion(),
+        DataFactory.stairs(),
+        DataFactory.ceiling(),
+        DataFactory.double_tower_ceiling(),
+        DataFactory.hanging_points(),
+        DataFactory.checkerboard(),
+        DataFactory.hole(),
+        DataFactory.kill_you(),
+        DataFactory.random(size=8, seed=0),
+        # SurfaceNets makes this have negative volume until inverted
+        DataFactory.random(size=3, seed=55),
+    ],
+)
+def test_to_mesh_surface_nets(data: NDArray) -> None:
+    """Test MeshGenerator.to_mesh_surface_nets."""
+    mesh = MeshGenerator.to_mesh_surface_nets(data)
+    assert len(mesh.vertices) > 0
+    assert len(mesh.faces) > 0
+    assert mesh.volume > 0
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        DataFactory.simple_extrusion(),
+        DataFactory.double_extrusion(),
+        DataFactory.triple_extrusion(),
+        DataFactory.stairs(),
+        DataFactory.ceiling(),
+        DataFactory.double_tower_ceiling(),
+        DataFactory.hanging_points(),
+        DataFactory.checkerboard(),
+        DataFactory.hole(),
+        DataFactory.kill_you(),
+        DataFactory.random(size=8, seed=0),
+    ],
+)
+def test_to_mesh_dual_contouring(data: NDArray) -> None:
+    """Test MeshGenerator.to_mesh_dual_contouring."""
+    mesh = MeshGenerator.to_mesh_dual_contouring(data)
+    assert len(mesh.vertices) > 0
+    assert len(mesh.faces) > 0
+    assert mesh.volume > 0

edge_mender/tmp.py

@@ -1,3 +1,6 @@
+# type: ignore
+
+
 def repair(mesh):
     # Iterate over the mesh edges
     for edge in mesh:

pseudocode.py

@@ -59,4 +59,8 @@ unfixable = []
 convention = "numpy"
 
 [tool.ruff.lint.per-file-ignores]
+"pseudocode.py" = ["ALL"]
 "*/tests/*" = ["S101"]
+
+[tool.coverage.run]
+omit = ["conftest.py", "pseudocode.py", "edge_mender/Dual_Contouring_Voxel/*"]