test(all): update all tests to mathc the refactor

Author: Ludofr3

bot/core/cad.py

@@ -305,46 +305,40 @@ def get_corners(self, face_tag):
 
         return corners
 
-    def get_curve_discretization(self):
-        # Get mesh node tags and their coordinates
+    def get_curve_discretization(
+        self,
+    ) -> dict[int, tuple[list[tuple[float, float, float]], list[tuple[int, int]]]]:
+        """Per-curve 1D mesh: gmsh_tag -> (local_points, local_edges)."""
+        curves: dict[
+            int, tuple[list[tuple[float, float, float]], list[tuple[int, int]]]
+        ] = {}
         node_tags, coords, _ = gmsh.model.mesh.getNodes()
-        node_id_to_index = {tag: i for i, tag in enumerate(node_tags)}
-        # Get all the entities of dim 1
-        elem_types, elem_tags, elem_node_tags = gmsh.model.mesh.getElements(dim=1)
-
-        # On transforme la liste plate [x,y,z,x,y,z] en liste de tuples [(x,y,z), ...]
-        points_3d = []
-        for i in range(0, len(coords), 3):
-            points_3d.append((coords[i], coords[i + 1], coords[i + 2]))
-
-        # 2. Liste finale des données
-        # Structure : (index_sommet_A, index_sommet_B, tag_courbe_origine)
-        edges_with_metadata = []
-
-        # 3. Parcourir chaque "Courbe" (entité de dimension 1)
-        entities = gmsh.model.getEntities(1)
-
-        for entity in entities:
-            curve_tag = entity[1]  # C'est le Tag de la courbe CAO
-
-            # Récupérer les éléments (segments) appartenant UNIQUEMENT à cette courbe
-            _, _, node_tags_per_elem = gmsh.model.mesh.getElements(1, curve_tag)
+        node_id_to_coords = {
+            tag: (coords[i * 3], coords[i * 3 + 1], coords[i * 3 + 2])
+            for i, tag in enumerate(node_tags)
+        }
 
-            if len(node_tags_per_elem) > 0:
-                connectivity = node_tags_per_elem[0]
+        for entity in gmsh.model.getEntities(1):
+            gmsh_tag = entity[1]
+            _, _, node_tags_per_elem = gmsh.model.mesh.getElements(1, gmsh_tag)
+            if not node_tags_per_elem:
+                continue
 
-                # Parcourir les nœuds par paires pour former les arêtes
-                for i in range(0, len(connectivity), 2):
-                    tag_a = connectivity[i]
-                    tag_b = connectivity[i + 1]
+            connectivity = node_tags_per_elem[0]
+            seen: dict[int, int] = {}
+            local_points: list[tuple[float, float, float]] = []
+            local_edges: list[tuple[int, int]] = []
 
-                    # Conversion en indices (0, 1, 2...) pour Panda3D
-                    idx_a = node_id_to_index[tag_a]
-                    idx_b = node_id_to_index[tag_b]
+            for i in range(0, len(connectivity), 2):
+                for node_tag in (connectivity[i], connectivity[i + 1]):
+                    if node_tag not in seen:
+                        seen[node_tag] = len(local_points)
+                        local_points.append(node_id_to_coords[node_tag])
+                local_edges.append((seen[connectivity[i]], seen[connectivity[i + 1]]))
 
-                    edges_with_metadata.append((idx_a, idx_b, curve_tag))
+            curves[gmsh_tag] = (local_points, local_edges)
 
-        return points_3d, edges_with_metadata
+        return curves
 
     def _discretize_curves(self):
         self.__synchronize()

bot/viewer/viewable.py

@@ -5,8 +5,6 @@
 import logging
 from typing import Callable, Protocol
 
-import gmsh
-
 from bot.core.cad import CADModel
 from bot.core.spline import SplineModel
 from bot.viewer.contracts import CurveDelta, ScenePayload, ViewerCommand, ViewEvent
@@ -57,7 +55,7 @@ def unbind_update(self) -> None:
         self._update_callback = None
 
     def get_delta_load(self) -> ScenePayload:
-        changed_curves = self._build_all_curves()
+        changed_curves = self._build_changed_curves()
         flat_points, flat_edges = self._build_flat_topology(changed_curves)
         payload: ScenePayload = {
             "op": "add",
@@ -97,7 +95,7 @@ def update(self, _model: CADModel) -> None:
             self._update_callback(
                 {
                     "op": "update",
-                    "changed_curves": self._build_all_curves(),
+                    "changed_curves": self._build_changed_curves(),
                 }
             )
 
@@ -118,35 +116,13 @@ def _resolve_cad_tag_str(self, tag_str: str) -> int | None:
             return None
         return local_id
 
-    def _build_all_curves(self) -> dict[str, CurveDelta]:
+    def _build_changed_curves(self) -> dict[str, CurveDelta]:
         changed: dict[str, CurveDelta] = {}
         try:
-            node_tags, coords, _ = gmsh.model.mesh.getNodes()
-            node_id_to_coords = {
-                tag: (coords[i * 3], coords[i * 3 + 1], coords[i * 3 + 2])
-                for i, tag in enumerate(node_tags)
-            }
-
-            for entity in gmsh.model.getEntities(1):
-                gmsh_tag = entity[1]
-                _, _, node_tags_per_elem = gmsh.model.mesh.getElements(1, gmsh_tag)
-                if not node_tags_per_elem:
-                    continue
-
-                connectivity = node_tags_per_elem[0]
-                seen: dict[int, int] = {}
-                local_points: list[tuple[float, float, float]] = []
-                local_edges: list[tuple[int, int]] = []
-
-                for i in range(0, len(connectivity), 2):
-                    for node_tag in (connectivity[i], connectivity[i + 1]):
-                        if node_tag not in seen:
-                            seen[node_tag] = len(local_points)
-                            local_points.append(node_id_to_coords[node_tag])
-                    local_edges.append(
-                        (seen[connectivity[i]], seen[connectivity[i + 1]])
-                    )
-
+            for gmsh_tag, (
+                local_points,
+                local_edges,
+            ) in self._model.get_curve_discretization().items():
                 ns_tag = encode(CAD_NS, gmsh_tag)
                 changed[ns_tag] = pack_curve_delta(
                     local_points,

tests/system/test_cad_workflow.py

@@ -2,15 +2,21 @@
 System tests — full CAD workflow.
 
 These tests exercise the Model end-to-end: file loading, topology queries,
-point addition and render-data consistency.  No Panda3D required.
+point addition and curve-discretization consistency.  No Panda3D required.
 """
 
+import pickle
 import unittest
-from bot.core.cad import Model as CADModel
+
+from bot.core.cad import CADModel
 
 GEO_FILE = "data/profil_1.geo"
 
 
+def _total_vertices(discretization):
+    return sum(len(pts) for pts, _ in discretization.values())
+
+
 class TestLoadAndTopology(unittest.TestCase):
     """Open profil_1.geo and verify the full topology is coherent."""
 
@@ -48,8 +54,8 @@ def test_get_adjacent_points_returns_two_per_curve(self):
             self.assertEqual(2, len(self.cad.get_adjacent_points(tag)))
 
 
-class TestRenderDataCoherence(unittest.TestCase):
-    """Verify get_render_data() returns a consistent, picklable snapshot."""
+class TestCurveDiscretizationCoherence(unittest.TestCase):
+    """Verify get_curve_discretization() and bounds stay consistent."""
 
     def setUp(self):
         self.cad = CADModel()
@@ -58,41 +64,48 @@ def setUp(self):
     def tearDown(self):
         self.cad.finalize()
 
-    def test_render_data_has_all_keys(self):
-        data = self.cad.get_render_data()
-        self.assertIn("points", data)
-        self.assertIn("edges", data)
-        self.assertIn("bounds", data)
+    def test_discretization_has_one_entry_per_curve(self):
+        discretization = self.cad.get_curve_discretization()
+        self.assertEqual(len(self.cad.get_curve_tags()), len(discretization))
+        for tag in self.cad.get_curve_tags():
+            self.assertIn(tag, discretization)
 
     def test_edges_reference_valid_point_indices(self):
-        data = self.cad.get_render_data()
-        n = len(data["points"])
-        for idx_a, idx_b, _curve_tag in data["edges"]:
-            self.assertGreaterEqual(idx_a, 0)
-            self.assertLess(idx_a, n)
-            self.assertGreaterEqual(idx_b, 0)
-            self.assertLess(idx_b, n)
+        for pts, edges in self.cad.get_curve_discretization().values():
+            n = len(pts)
+            for idx_a, idx_b in edges:
+                self.assertGreaterEqual(idx_a, 0)
+                self.assertLess(idx_a, n)
+                self.assertGreaterEqual(idx_b, 0)
+                self.assertLess(idx_b, n)
+
+    def test_bounds_has_expected_keys(self):
+        bounds = self.cad.bounds
+        for key in ("min", "max", "center", "size"):
+            self.assertIn(key, bounds)
 
     def test_bounds_center_is_inside_min_max(self):
-        bounds = self.cad.get_render_data()["bounds"]
+        bounds = self.cad.bounds
         for axis in range(3):
             self.assertGreaterEqual(bounds["center"][axis], bounds["min"][axis] - 1e-9)
             self.assertLessEqual(bounds["center"][axis], bounds["max"][axis] + 1e-9)
 
     def test_bounds_size_matches_min_max(self):
-        bounds = self.cad.get_render_data()["bounds"]
+        bounds = self.cad.bounds
         for axis in range(3):
             expected = bounds["max"][axis] - bounds["min"][axis]
             self.assertAlmostEqual(bounds["size"][axis], expected, places=9)
 
-    def test_render_data_is_picklable(self):
-        import pickle
-
-        data = self.cad.get_render_data()
-        serialised = pickle.dumps(data)
+    def test_discretization_is_picklable(self):
+        discretization = self.cad.get_curve_discretization()
+        serialised = pickle.dumps(discretization)
         restored = pickle.loads(serialised)
-        self.assertEqual(data["bounds"], restored["bounds"])
-        self.assertEqual(len(data["points"]), len(restored["points"]))
+        self.assertEqual(len(discretization), len(restored))
+        for tag, (pts, edges) in discretization.items():
+            self.assertIn(tag, restored)
+            restored_pts, restored_edges = restored[tag]
+            self.assertEqual(pts, restored_pts)
+            self.assertEqual(edges, restored_edges)
 
 
 class TestAddPointWorkflow(unittest.TestCase):
@@ -102,7 +115,6 @@ def setUp(self):
         self.cad = CADModel()
         self.cad.open(GEO_FILE)
         self.initial_point_count = len(self.cad.get_point_tags())
-        self.initial_render_pts = len(self.cad.get_render_data()["points"])
 
     def tearDown(self):
         self.cad.finalize()
@@ -118,17 +130,16 @@ def test_add_point_returns_valid_tag(self):
         tag = self.cad.add_point([1.0, 1.0, 0.0])
         self.assertIn(tag, self.cad.get_point_tags())
 
-    def test_add_point_updates_render_data(self):
+    def test_add_point_updates_discretization(self):
         self.cad.add_point([100.0, 100.0, 0.0])
-        new_count = len(self.cad.get_render_data()["points"])
-        # Mesh is regenerated: number of discretisation nodes changes
+        new_count = _total_vertices(self.cad.get_curve_discretization())
         self.assertGreater(new_count, 0)
 
     def test_bounds_extend_when_point_is_outside(self):
-        old_bounds = self.cad.get_render_data()["bounds"]
+        old_bounds = self.cad.bounds
         far_x = old_bounds["max"][0] + 1000.0
         self.cad.add_point([far_x, 0.0, 0.0])
-        new_bounds = self.cad.get_render_data()["bounds"]
+        new_bounds = self.cad.bounds
         self.assertGreaterEqual(new_bounds["max"][0], far_x - 1e-6)
 
     def test_cumulative_additions(self):