@geode/opengeodeweb-front 10.2.1-rc.3 → 10.2.1-rc.4

package/app/components/Viewer/Solid/SpecificPolyhedraOptions.vue

@@ -39,16 +39,16 @@
     },
   })
   const vertex_attribute = computed({
-    get: () => dataStyleStore.polyhedraVertexAttribute(id.value),
+    get: () => dataStyleStore.meshPolyhedraVertexAttribute(id.value),
     set: (newValue) => {
-      dataStyleStore.setPolyhedraVertexAttribute(id.value, newValue)
+      dataStyleStore.setMeshPolyhedraVertexAttribute(id.value, newValue)
       hybridViewerStore.remoteRender()
     },
   })
   const polyhedron_attribute = computed({
-    get: () => dataStyleStore.polyhedraPolyhedronAttribute(id.value),
+    get: () => dataStyleStore.meshPolyhedraPolyhedronAttribute(id.value),
     set: (newValue) => {
-      dataStyleStore.setPolyhedraPolyhedronAttribute(id.value, newValue)
+      dataStyleStore.setMeshPolyhedraPolyhedronAttribute(id.value, newValue)
       hybridViewerStore.remoteRender()
     },
   })

package/internal/stores/mesh/cells.js

@@ -131,17 +131,17 @@ export function useMeshCellsStyle() {
       return setMeshCellsColor(id, coloring.color)
     } else if (type === "textures") {
       if (coloring.textures === null) {
-        return
+        throw new Error("Textures not set")
       }
       return setMeshCellsTextures(id, coloring.textures)
     } else if (type === "vertex") {
       if (coloring.vertex === null) {
-        return
+        throw new Error("Vertex attribute not set")
       }
       return setMeshCellsVertexAttribute(id, coloring.vertex)
     } else if (type === "cell") {
       if (coloring.cell === null) {
-        return
+        throw new Error("Cell attribute not set")
       }
       return setMeshCellsCellAttribute(id, coloring.cell)
     } else {

package/internal/stores/mesh/edges.js

@@ -51,12 +51,12 @@ export function useMeshEdgesStyle() {
       return setMeshEdgesColor(id, coloring.color)
     } else if (type === "vertex") {
       if (coloring.vertex === null) {
-        return
+        throw new Error("Vertex attribute not set")
       }
       return setMeshEdgesVertexAttribute(id, coloring.vertex)
     } else if (type === "edge") {
       if (coloring.edge === null) {
-        return
+        throw new Error("Edge attribute not set")
       }
       return setMeshEdgesEdgeAttribute(id, coloring.edge)
     } else {

package/internal/stores/mesh/points.js

@@ -52,7 +52,7 @@ export function useMeshPointsStyle() {
       return setMeshPointsColor(id, coloring.color)
     } else if (type === "vertex") {
       if (coloring.vertex === null) {
-        return
+        throw new Error("Vertex attribute not set")
       }
       return setMeshPointsVertexAttribute(id, coloring.vertex)
     } else {

package/internal/stores/mesh/polygons.js

@@ -137,17 +137,17 @@ export function useMeshPolygonsStyle() {
       return setMeshPolygonsColor(id, coloring.color)
     } else if (type === "textures") {
       if (coloring.textures === null) {
-        return
+        throw new Error("Textures not set")
       }
       return setMeshPolygonsTextures(id, coloring.textures)
     } else if (type === "vertex") {
       if (coloring.vertex === null) {
-        return
+        throw new Error("Vertex attribute not set")
       }
       return setMeshPolygonsVertexAttribute(id, coloring.vertex)
     } else if (type === "polygon") {
       if (coloring.polygon === null) {
-        return
+        throw new Error("Polygon attribute not set")
       }
       return setMeshPolygonsPolygonAttribute(id, coloring.polygon)
     } else {

package/internal/stores/mesh/polyhedra.js

@@ -51,14 +51,14 @@ export function useMeshPolyhedraStyle() {
       return setMeshPolyhedraColor(id, coloring.color)
     } else if (type === "vertex") {
       if (coloring.vertex === null) {
-        return
+        throw new Error("Vertex attribute not set")
       }
-      return setPolyhedraVertexAttribute(id, coloring.vertex)
+      return setMeshPolyhedraVertexAttribute(id, coloring.vertex)
     } else if (type === "polyhedron") {
       if (coloring.polyhedron === null) {
-        return
+        throw new Error("Polyhedron attribute not set")
       }
-      return setPolyhedraPolyhedronAttribute(id, coloring.polyhedron)
+      return setMeshPolyhedraPolyhedronAttribute(id, coloring.polyhedron)
     } else {
       throw new Error("Unknown mesh polyhedra coloring type: " + type)
     }
@@ -85,10 +85,10 @@ export function useMeshPolyhedraStyle() {
     )
   }
 
-  function polyhedraVertexAttribute(id) {
+  function meshPolyhedraVertexAttribute(id) {
     return meshPolyhedraStyle(id).coloring.vertex
   }
-  function setPolyhedraVertexAttribute(id, vertex_attribute) {
+  function setMeshPolyhedraVertexAttribute(id, vertex_attribute) {
     const coloring_style = meshPolyhedraStyle(id).coloring
     return viewerStore.request(
       mesh_polyhedra_schemas.vertex_attribute,
@@ -97,19 +97,19 @@ export function useMeshPolyhedraStyle() {
         response_function: () => {
           coloring_style.vertex = vertex_attribute
           console.log(
-            setPolyhedraVertexAttribute.name,
+            setMeshPolyhedraVertexAttribute.name,
             { id },
-            polyhedraVertexAttribute(id),
+            meshPolyhedraVertexAttribute(id),
           )
         },
       },
     )
   }
 
-  function polyhedraPolyhedronAttribute(id) {
+  function meshPolyhedraPolyhedronAttribute(id) {
     return meshPolyhedraStyle(id).coloring.polyhedron
   }
-  function setPolyhedraPolyhedronAttribute(id, polyhedron_attribute) {
+  function setMeshPolyhedraPolyhedronAttribute(id, polyhedron_attribute) {
     const coloring = meshPolyhedraStyle(id).coloring
     return viewerStore.request(
       mesh_polyhedra_schemas.polyhedron_attribute,
@@ -118,9 +118,9 @@ export function useMeshPolyhedraStyle() {
         response_function: () => {
           coloring.polyhedron = polyhedron_attribute
           console.log(
-            setPolyhedraPolyhedronAttribute.name,
+            setMeshPolyhedraPolyhedronAttribute.name,
             { id },
-            polyhedraPolyhedronAttribute(id),
+            meshPolyhedraPolyhedronAttribute(id),
           )
         },
       },
@@ -139,13 +139,13 @@ export function useMeshPolyhedraStyle() {
     applyMeshPolyhedraStyle,
     meshPolyhedraActiveColoring,
     meshPolyhedraColor,
-    polyhedraVertexAttribute,
+    meshPolyhedraVertexAttribute,
     meshPolyhedraVisibility,
-    polyhedraPolyhedronAttribute,
+    meshPolyhedraPolyhedronAttribute,
     setMeshPolyhedraActiveColoring,
     setMeshPolyhedraColor,
-    setPolyhedraPolyhedronAttribute,
-    setPolyhedraVertexAttribute,
+    setMeshPolyhedraPolyhedronAttribute,
+    setMeshPolyhedraVertexAttribute,
     setMeshPolyhedraVisibility,
   }
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@geode/opengeodeweb-front",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "type": "module",
-  "version": "10.2.1-rc.3",
+  "version": "10.2.1-rc.4",
   "main": "./nuxt.config.js",
   "scripts": {
     "lint": "eslint --fix --ext .js,.vue --ignore-path .gitignore .",

package/tests/integration/microservices/back/requirements.txt

@@ -5,4 +5,4 @@
 #    pip-compile --output-file=tests/integration/microservices/back/requirements.txt tests/integration/microservices/back/requirements.in
 #
 
-opengeodeweb-back==6.*,>=6.0.0
+opengeodeweb-back==6.*,>=6.1.0rc2

package/tests/integration/stores/data_style/mesh/cells.nuxt.test.js

@@ -17,6 +17,8 @@ import { setupIntegrationTests } from "../../../setup"
 const mesh_cells_schemas = viewer_schemas.opengeodeweb_viewer.mesh.cells
 const file_name = "test.og_rgd2d"
 const geode_object = "RegularGrid2D"
+const vertex_attribute = { name: "points" }
+const cell_attribute = { name: "RGB_data" }
 
 let id, back_port, viewer_port, project_folder_path
 
@@ -44,7 +46,9 @@ describe("Mesh cells", () => {
       const viewerStore = useViewerStore()
       const visibility = true
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshCellsVisibility(id, visibility)
+      const result = dataStyleStore.setMeshCellsVisibility(id, visibility)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_cells_schemas.visibility,
         { id, visibility },
@@ -63,7 +67,9 @@ describe("Mesh cells", () => {
       const viewerStore = useViewerStore()
       const color = { r: 255, g: 0, b: 0 }
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshCellsColor(id, color)
+      const result = dataStyleStore.setMeshCellsColor(id, color)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_cells_schemas.color,
         { id, color },
@@ -80,9 +86,13 @@ describe("Mesh cells", () => {
     test("Coloring vertex attribute", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      const vertex_attribute = { name: "points" }
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshCellsVertexAttribute(id, vertex_attribute)
+      const result = dataStyleStore.setMeshCellsVertexAttribute(
+        id,
+        vertex_attribute,
+      )
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_cells_schemas.vertex_attribute,
         { id, ...vertex_attribute },
@@ -101,9 +111,13 @@ describe("Mesh cells", () => {
     test("Coloring cell attribute", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      const cell_attribute = { name: "RGB_data" }
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshCellsCellAttribute(id, cell_attribute)
+      const result = dataStyleStore.setMeshCellsCellAttribute(
+        id,
+        cell_attribute,
+      )
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_cells_schemas.cell_attribute,
         { id, ...cell_attribute },
@@ -122,11 +136,37 @@ describe("Mesh cells", () => {
     test("test coloring", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      const coloringTypes = ["color", "vertex", "cell"]
+      const coloringTypes = [
+        { name: "color" },
+        {
+          name: "vertex",
+          function: () =>
+            dataStyleStore.setMeshCellsVertexAttribute(id, vertex_attribute),
+        },
+        {
+          name: "cell",
+          function: () =>
+            dataStyleStore.setMeshCellsCellAttribute(id, cell_attribute),
+        },
+      ]
       for (let i = 0; i < coloringTypes.length; i++) {
-        dataStyleStore.setMeshCellsActiveColoring(id, coloringTypes[i])
+        if (coloringTypes[i].function) {
+          expect(() =>
+            dataStyleStore.setMeshCellsActiveColoring(
+              id,
+              coloringTypes[i].name,
+            ),
+          ).toThrowError()
+          await coloringTypes[i].function()
+        }
+        const result = dataStyleStore.setMeshCellsActiveColoring(
+          id,
+          coloringTypes[i].name,
+        )
+        expect(result).toBeInstanceOf(Promise)
+        await result
         expect(dataStyleStore.meshCellsActiveColoring(id)).toBe(
-          coloringTypes[i],
+          coloringTypes[i].name,
         )
         expect(viewerStore.status).toBe(Status.CONNECTED)
       }

package/tests/integration/stores/data_style/mesh/edges.nuxt.test.js

@@ -17,6 +17,8 @@ import { setupIntegrationTests } from "../../../setup"
 const mesh_edges_schemas = viewer_schemas.opengeodeweb_viewer.mesh.edges
 const file_name = "test.og_edc3d"
 const geode_object = "EdgedCurve3D"
+const vertex_attribute = { name: "vertex_attribute" }
+const edge_attribute = { name: "edge_attribute" }
 
 let id, back_port, viewer_port, project_folder_path
 
@@ -36,14 +38,16 @@ afterEach(async () => {
   delete_folder_recursive(project_folder_path)
 })
 
-describe("Mesh EdgedCurve3D", () => {
+describe("Mesh edges", () => {
   describe("Edges", () => {
     test("Edges visibility", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const visibility = true
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshEdgesVisibility(id, visibility)
+      const result = dataStyleStore.setMeshEdgesVisibility(id, visibility)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_edges_schemas.visibility,
         { id, visibility },
@@ -60,7 +64,9 @@ describe("Mesh EdgedCurve3D", () => {
       const viewerStore = useViewerStore()
       const color = { r: 255, g: 0, b: 0 }
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshEdgesColor(id, color)
+      const result = dataStyleStore.setMeshEdgesColor(id, color)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_edges_schemas.color,
         { id, color },
@@ -72,23 +78,10 @@ describe("Mesh EdgedCurve3D", () => {
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
 
-    test("Edges active coloring", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const coloringTypes = ["color", "vertex", "edge"]
-      for (let i = 0; i < coloringTypes.length; i++) {
-        dataStyleStore.setMeshEdgesActiveColoring(id, coloringTypes[i])
-        expect(dataStyleStore.meshEdgesActiveColoring(id)).toBe(
-          coloringTypes[i],
-        )
-        expect(viewerStore.status).toBe(Status.CONNECTED)
-      }
-    })
-
     test("Edges vertex attribute", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      const vertex_attribute = { name: "vertex_attribute" }
+
       const spy = vi.spyOn(viewerStore, "request")
       await dataStyleStore.setMeshEdgesVertexAttribute(id, vertex_attribute)
       expect(spy).toHaveBeenCalledWith(
@@ -107,7 +100,7 @@ describe("Mesh EdgedCurve3D", () => {
     test("Edges edge attribute", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      const edge_attribute = { name: "edge_attribute" }
+
       const spy = vi.spyOn(viewerStore, "request")
       await dataStyleStore.setMeshEdgesEdgeAttribute(id, edge_attribute)
       expect(spy).toHaveBeenCalledWith(
@@ -122,5 +115,44 @@ describe("Mesh EdgedCurve3D", () => {
       )
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
+
+    test("Edges active coloring", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const coloringTypes = [
+        { name: "color" },
+        {
+          name: "vertex",
+          function: () =>
+            dataStyleStore.setMeshEdgesVertexAttribute(id, vertex_attribute),
+        },
+        {
+          name: "edge",
+          function: () =>
+            dataStyleStore.setMeshEdgesEdgeAttribute(id, edge_attribute),
+        },
+      ]
+      for (let i = 0; i < coloringTypes.length; i++) {
+        if (coloringTypes[i].function) {
+          expect(() =>
+            dataStyleStore.setMeshEdgesActiveColoring(
+              id,
+              coloringTypes[i].name,
+            ),
+          ).toThrowError()
+          await coloringTypes[i].function()
+        }
+        const result = dataStyleStore.setMeshEdgesActiveColoring(
+          id,
+          coloringTypes[i].name,
+        )
+        expect(result).toBeInstanceOf(Promise)
+        await result
+        expect(dataStyleStore.meshEdgesActiveColoring(id)).toBe(
+          coloringTypes[i].name,
+        )
+        expect(viewerStore.status).toBe(Status.CONNECTED)
+      }
+    })
   })
 })

package/tests/integration/stores/data_style/mesh/index.nuxt.test.js

@@ -43,7 +43,9 @@ describe("Mesh", () => {
       const viewerStore = useViewerStore()
       const visibility = true
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshVisibility(id, visibility)
+      const result = dataStyleStore.setMeshVisibility(id, visibility)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_schemas.visibility,
         { id, visibility },
@@ -60,7 +62,9 @@ describe("Mesh", () => {
     test("test", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      await dataStyleStore.applyMeshStyle(id)
+      const result = dataStyleStore.applyMeshStyle(id)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
   })

package/tests/integration/stores/data_style/mesh/points.nuxt.test.js

@@ -17,6 +17,7 @@ import { setupIntegrationTests } from "../../../setup"
 const mesh_points_schemas = viewer_schemas.opengeodeweb_viewer.mesh.points
 const file_name = "test.og_edc2d"
 const geode_object = "EdgedCurve2D"
+const vertex_attribute = { name: "points" }
 
 let id, back_port, viewer_port, project_folder_path
 
@@ -43,7 +44,9 @@ describe("Mesh points", () => {
       const viewerStore = useViewerStore()
       const visibility = true
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshPointsVisibility(id, visibility)
+      const result = dataStyleStore.setMeshPointsVisibility(id, visibility)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_points_schemas.visibility,
         { id, visibility },
@@ -62,7 +65,9 @@ describe("Mesh points", () => {
       const viewerStore = useViewerStore()
       const color = { r: 255, g: 0, b: 0 }
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshPointsColor(id, color)
+      const result = dataStyleStore.setMeshPointsColor(id, color)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_points_schemas.color,
         { id, color },
@@ -79,11 +84,32 @@ describe("Mesh points", () => {
     test("test coloring", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      const coloringTypes = ["color"]
+      const coloringTypes = [
+        { name: "color" },
+        {
+          name: "vertex",
+          function: () =>
+            dataStyleStore.setMeshPointsVertexAttribute(id, vertex_attribute),
+        },
+      ]
       for (let i = 0; i < coloringTypes.length; i++) {
-        dataStyleStore.setMeshPointsActiveColoring(id, coloringTypes[i])
+        if (coloringTypes[i].function) {
+          expect(() =>
+            dataStyleStore.setMeshPointsActiveColoring(
+              id,
+              coloringTypes[i].name,
+            ),
+          ).toThrowError()
+          await coloringTypes[i].function()
+        }
+        const result = dataStyleStore.setMeshPointsActiveColoring(
+          id,
+          coloringTypes[i].name,
+        )
+        expect(result).toBeInstanceOf(Promise)
+        await result
         expect(dataStyleStore.meshPointsActiveColoring(id)).toBe(
-          coloringTypes[i],
+          coloringTypes[i].name,
         )
         expect(viewerStore.status).toBe(Status.CONNECTED)
       }
@@ -96,7 +122,9 @@ describe("Mesh points", () => {
       const viewerStore = useViewerStore()
       const size = 20
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshPointsSize(id, size)
+      const result = dataStyleStore.setMeshPointsSize(id, size)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_points_schemas.size,
         { id, size },
@@ -111,7 +139,7 @@ describe("Mesh points", () => {
     test("Points vertex attribute", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      const vertex_attribute = { name: "points" }
+
       const spy = vi.spyOn(viewerStore, "request")
       await dataStyleStore.setMeshPointsVertexAttribute(id, vertex_attribute)
       expect(spy).toHaveBeenCalledWith(

package/tests/integration/stores/data_style/mesh/polygons.nuxt.test.js

@@ -17,6 +17,8 @@ import { setupIntegrationTests } from "../../../setup"
 const mesh_polygons_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polygons
 const file_name = "test.og_psf3d"
 const geode_object = "PolygonalSurface3D"
+const vertex_attribute = { name: "points" }
+const polygon_attribute = { name: "test_attribute" }
 
 let id, back_port, viewer_port, project_folder_path
 
@@ -44,7 +46,9 @@ describe("Mesh polygons", () => {
       const viewerStore = useViewerStore()
       const visibility = true
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshPolygonsVisibility(id, visibility)
+      const result = dataStyleStore.setMeshPolygonsVisibility(id, visibility)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_polygons_schemas.visibility,
         { id, visibility },
@@ -63,7 +67,9 @@ describe("Mesh polygons", () => {
       const viewerStore = useViewerStore()
       const color = { r: 255, g: 0, b: 0 }
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshPolygonsColor(id, color)
+      const result = dataStyleStore.setMeshPolygonsColor(id, color)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_polygons_schemas.color,
         { id, color },
@@ -76,28 +82,17 @@ describe("Mesh polygons", () => {
     })
   })
 
-  describe("Polygons active coloring", () => {
-    test("test coloring", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const coloringTypes = ["color", "vertex", "polygon"]
-      for (let i = 0; i < coloringTypes.length; i++) {
-        dataStyleStore.setMeshPolygonsActiveColoring(id, coloringTypes[i])
-        expect(dataStyleStore.meshPolygonsActiveColoring(id)).toBe(
-          coloringTypes[i],
-        )
-        expect(viewerStore.status).toBe(Status.CONNECTED)
-      }
-    })
-  })
-
   describe("Polygons vertex attribute", () => {
     test("Coloring vertex attribute", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      const vertex_attribute = { name: "points" }
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshPolygonsVertexAttribute(id, vertex_attribute)
+      const result = dataStyleStore.setMeshPolygonsVertexAttribute(
+        id,
+        vertex_attribute,
+      )
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_polygons_schemas.vertex_attribute,
         { id, ...vertex_attribute },
@@ -116,12 +111,13 @@ describe("Mesh polygons", () => {
     test("Coloring polygon attribute", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      const polygon_attribute = { name: "test_attribute" }
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshPolygonsPolygonAttribute(
+      const result = dataStyleStore.setMeshPolygonsPolygonAttribute(
         id,
         polygon_attribute,
       )
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_polygons_schemas.polygon_attribute,
         { id, ...polygon_attribute },
@@ -135,4 +131,49 @@ describe("Mesh polygons", () => {
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
   })
+
+  describe("Polygons active coloring", () => {
+    test("test coloring", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const coloringTypes = [
+        { name: "color" },
+        {
+          name: "vertex",
+          function: () =>
+            dataStyleStore.setMeshPolygonsVertexAttribute(id, vertex_attribute),
+        },
+        {
+          name: "polygon",
+          function: () =>
+            dataStyleStore.setMeshPolygonsPolygonAttribute(
+              id,
+              polygon_attribute,
+            ),
+        },
+      ]
+
+      for (let i = 0; i < coloringTypes.length; i++) {
+        if (coloringTypes[i].function) {
+          expect(() =>
+            dataStyleStore.setMeshPolygonsActiveColoring(
+              id,
+              coloringTypes[i].name,
+            ),
+          ).toThrowError()
+          await coloringTypes[i].function()
+        }
+        const result = dataStyleStore.setMeshPolygonsActiveColoring(
+          id,
+          coloringTypes[i].name,
+        )
+        expect(result).toBeInstanceOf(Promise)
+        await result
+        expect(dataStyleStore.meshPolygonsActiveColoring(id)).toBe(
+          coloringTypes[i].name,
+        )
+        expect(viewerStore.status).toBe(Status.CONNECTED)
+      }
+    })
+  })
 })

package/tests/integration/stores/data_style/mesh/polyhedra.nuxt.test.js

@@ -15,10 +15,10 @@ import { setupIntegrationTests } from "../../../setup"
 
 // Local constants
 const mesh_polyhedra_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra
-const mesh_polygons_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polygons
-const mesh_edges_schemas = viewer_schemas.opengeodeweb_viewer.mesh.edges
 const file_name = "test.vtu"
 const geode_object = "HybridSolid3D"
+const vertex_attribute = { name: "toto_on_vertices" }
+const polyhedron_attribute = { name: "toto_on_polyhedra" }
 
 let id, back_port, viewer_port, project_folder_path
 
@@ -45,7 +45,9 @@ describe("Mesh polyhedra", () => {
       const viewerStore = useViewerStore()
       const visibility = true
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshPolyhedraVisibility(id, visibility)
+      const result = dataStyleStore.setMeshPolyhedraVisibility(id, visibility)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_polyhedra_schemas.visibility,
         { id, visibility },
@@ -62,7 +64,9 @@ describe("Mesh polyhedra", () => {
       const viewerStore = useViewerStore()
       const color = { r: 255, g: 0, b: 0 }
       const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshPolyhedraColor(id, color)
+      const result = dataStyleStore.setMeshPolyhedraColor(id, color)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         mesh_polyhedra_schemas.color,
         { id, color },
@@ -77,55 +81,87 @@ describe("Mesh polyhedra", () => {
     test("Polyhedra active coloring", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      const coloringTypes = ["color", "vertex", "polyhedron"]
+      const coloringTypes = [
+        { name: "color" },
+        {
+          name: "vertex",
+          function: () =>
+            dataStyleStore.setMeshPolyhedraVertexAttribute(
+              id,
+              vertex_attribute,
+            ),
+        },
+        {
+          name: "polyhedron",
+          function: () =>
+            dataStyleStore.setMeshPolyhedraPolyhedronAttribute(
+              id,
+              polyhedron_attribute,
+            ),
+        },
+      ]
       for (let i = 0; i < coloringTypes.length; i++) {
-        dataStyleStore.setMeshPolyhedraActiveColoring(id, coloringTypes[i])
+        if (coloringTypes[i].function) {
+          expect(() =>
+            dataStyleStore.setMeshPolyhedraActiveColoring(
+              id,
+              coloringTypes[i].name,
+            ),
+          ).toThrowError()
+          await coloringTypes[i].function()
+        }
+        const result = dataStyleStore.setMeshPolyhedraActiveColoring(
+          id,
+          coloringTypes[i].name,
+        )
+        expect(result).toBeInstanceOf(Promise)
+        await result
         expect(dataStyleStore.meshPolyhedraActiveColoring(id)).toBe(
-          coloringTypes[i],
+          coloringTypes[i].name,
         )
         expect(viewerStore.status).toBe(Status.CONNECTED)
       }
     })
+  })
 
-    test("Polyhedra vertex attribute", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const vertex_attribute = { name: "toto_on_vertices" }
-      const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setPolyhedraVertexAttribute(id, vertex_attribute)
-      expect(spy).toHaveBeenCalledWith(
-        mesh_polyhedra_schemas.vertex_attribute,
-        { id, ...vertex_attribute },
-        {
-          response_function: expect.any(Function),
-        },
-      )
-      expect(dataStyleStore.polyhedraVertexAttribute(id)).toStrictEqual(
-        vertex_attribute,
-      )
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
+  test("Polyhedra vertex attribute", async () => {
+    const dataStyleStore = useDataStyleStore()
+    const viewerStore = useViewerStore()
 
-    test("Polyhedra polyhedron attribute", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const polyhedron_attribute = { name: "toto_on_polyhedra" }
-      const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setPolyhedraPolyhedronAttribute(
-        id,
-        polyhedron_attribute,
-      )
-      expect(spy).toHaveBeenCalledWith(
-        mesh_polyhedra_schemas.polyhedron_attribute,
-        { id, ...polyhedron_attribute },
-        {
-          response_function: expect.any(Function),
-        },
-      )
-      expect(dataStyleStore.polyhedraPolyhedronAttribute(id)).toStrictEqual(
-        polyhedron_attribute,
-      )
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
+    const spy = vi.spyOn(viewerStore, "request")
+    await dataStyleStore.setMeshPolyhedraVertexAttribute(id, vertex_attribute)
+    expect(spy).toHaveBeenCalledWith(
+      mesh_polyhedra_schemas.vertex_attribute,
+      { id, ...vertex_attribute },
+      {
+        response_function: expect.any(Function),
+      },
+    )
+    expect(dataStyleStore.meshPolyhedraVertexAttribute(id)).toStrictEqual(
+      vertex_attribute,
+    )
+    expect(viewerStore.status).toBe(Status.CONNECTED)
+  })
+
+  test("Polyhedra polyhedron attribute", async () => {
+    const dataStyleStore = useDataStyleStore()
+    const viewerStore = useViewerStore()
+
+    const spy = vi.spyOn(viewerStore, "request")
+    await dataStyleStore.setMeshPolyhedraPolyhedronAttribute(
+      id,
+      polyhedron_attribute,
+    )
+    expect(spy).toHaveBeenCalledWith(
+      mesh_polyhedra_schemas.polyhedron_attribute,
+      { id, ...polyhedron_attribute },
+      {
+        response_function: expect.any(Function),
+      },
+    )
+    expect(dataStyleStore.meshPolyhedraPolyhedronAttribute(id)).toStrictEqual(
+      polyhedron_attribute,
+    )
+    expect(viewerStore.status).toBe(Status.CONNECTED)
   })
 })

package/tests/integration/stores/data_style/model/blocks.nuxt.test.js

@@ -51,7 +51,13 @@ describe("Model blocks", () => {
       const visibility = false
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
-      await dataStyleStore.setModelBlocksVisibility(id, block_ids, visibility)
+      const result = dataStyleStore.setModelBlocksVisibility(
+        id,
+        block_ids,
+        visibility,
+      )
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         model_blocks_schemas.visibility,
         { id, block_ids: block_viewer_ids, visibility },

package/tests/integration/stores/data_style/model/corners.nuxt.test.js

@@ -51,7 +51,13 @@ describe("Model corners", () => {
       const visibility = false
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
-      await dataStyleStore.setModelCornersVisibility(id, corner_ids, visibility)
+      const result = dataStyleStore.setModelCornersVisibility(
+        id,
+        corner_ids,
+        visibility,
+      )
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         model_corners_schemas.visibility,
         { id, block_ids: corner_viewer_ids, visibility },
@@ -81,7 +87,9 @@ describe("Model corners", () => {
       const color = { r: 255, g: 0, b: 0 }
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
-      await dataStyleStore.setModelCornersColor(id, corner_ids, color)
+      const result = dataStyleStore.setModelCornersColor(id, corner_ids, color)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         model_corners_schemas.color,
         { id, block_ids: corner_viewer_ids, color },

package/tests/integration/stores/data_style/model/edges.nuxt.test.js

@@ -44,7 +44,9 @@ describe("Model edges", () => {
       const visibility = true
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
-      await dataStyleStore.setModelEdgesVisibility(id, visibility)
+      const result = dataStyleStore.setModelEdgesVisibility(id, visibility)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         model_edges_schemas.visibility,
         { id, visibility },

package/tests/integration/stores/data_style/model/index.nuxt.test.js

@@ -44,7 +44,9 @@ describe("Model", () => {
       const visibility = true
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
-      await dataStyleStore.setModelVisibility(id, visibility)
+      const result = dataStyleStore.setModelVisibility(id, visibility)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         model_schemas.visibility,
         { id, visibility },

package/tests/integration/stores/data_style/model/lines.nuxt.test.js

@@ -47,7 +47,13 @@ describe("Model lines", () => {
       const visibility = false
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
-      await dataStyleStore.setModelLinesVisibility(id, line_ids, visibility)
+      const result = dataStyleStore.setModelLinesVisibility(
+        id,
+        line_ids,
+        visibility,
+      )
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         model_lines_schemas.visibility,
         { id, block_ids: lines_viewer_ids, visibility },
@@ -75,7 +81,9 @@ describe("Model lines", () => {
       const color = { r: 255, g: 0, b: 0 }
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
-      await dataStyleStore.setModelLinesColor(id, line_ids, color)
+      const result = dataStyleStore.setModelLinesColor(id, line_ids, color)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         model_lines_schemas.color,
         { id, block_ids: lines_viewer_ids, color },

package/tests/integration/stores/data_style/model/points.nuxt.test.js

@@ -39,7 +39,9 @@ describe("Model points", () => {
       const visibility = true
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
-      await dataStyleStore.setModelPointsVisibility(id, visibility)
+      const result = dataStyleStore.setModelPointsVisibility(id, visibility)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         model_points_schemas.visibility,
         { id, visibility },
@@ -59,7 +61,9 @@ describe("Model points", () => {
       const size = 20
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
-      await dataStyleStore.setModelPointsSize(id, size)
+      const result = dataStyleStore.setModelPointsSize(id, size)
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         model_points_schemas.size,
         { id, size },

package/tests/integration/stores/data_style/model/surfaces.nuxt.test.js

@@ -51,11 +51,13 @@ describe("Model surfaces", () => {
       const visibility = true
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear() // Clear calls from setup (applyDefaultStyle)
-      await dataStyleStore.setModelSurfacesVisibility(
+      const result = dataStyleStore.setModelSurfacesVisibility(
         id,
         surface_ids,
         visibility,
       )
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         model_surfaces_schemas.visibility,
         { id, block_ids: surface_viewer_ids, visibility },
@@ -85,7 +87,13 @@ describe("Model surfaces", () => {
       const color = { r: 255, g: 0, b: 0 }
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear() // Clear calls from setup (applyDefaultStyle)
-      await dataStyleStore.setModelSurfacesColor(id, surface_ids, color)
+      const result = dataStyleStore.setModelSurfacesColor(
+        id,
+        surface_ids,
+        color,
+      )
+      expect(result).toBeInstanceOf(Promise)
+      await result
       expect(spy).toHaveBeenCalledWith(
         model_surfaces_schemas.color,
         { id, block_ids: surface_viewer_ids, color },