@geode/opengeodeweb-front 10.6.2 → 10.6.3-rc.1

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

@@ -1,182 +1,158 @@
 // Third party imports
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" };
 
 // Local imports
-import { Status } from "@ogw_front/utils/status"
-import { cleanupBackend } from "@ogw_front/utils/local/cleanup"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
-import { useDataStyleStore } from "@ogw_front/stores/data_style"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { Status } from "@ogw_front/utils/status";
+import { cleanupBackend } from "@ogw_front/utils/local/cleanup";
+import { setupIntegrationTests } from "@ogw_tests/integration/setup";
+import { useDataStyleStore } from "@ogw_front/stores/data_style";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const INTERVAL_TIMEOUT = 20_000
-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" }
+const INTERVAL_TIMEOUT = 20_000;
+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 = "",
-  projectFolderPath = ""
+  projectFolderPath = "";
 
 beforeEach(async () => {
-  ;({ id, projectFolderPath } = await setupIntegrationTests(
-    file_name,
-    geode_object,
-  ))
-}, INTERVAL_TIMEOUT)
+  ({ id, projectFolderPath } = await setupIntegrationTests(file_name, geode_object));
+}, INTERVAL_TIMEOUT);
 
 afterEach(async () => {
-  console.log("afterEach mesh polygons kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach mesh polygons kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 
 describe("Mesh polygons", () => {
   describe("Polygons visibility", () => {
     test("Visibility true", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const visibility = true
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshPolygonsVisibility(id, visibility)
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const visibility = true;
+      const spy = vi.spyOn(viewerStore, "request");
+      const result = dataStyleStore.setMeshPolygonsVisibility(id, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_polygons_schemas.visibility,
         { id, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshPolygonsVisibility(id)).toBe(visibility)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshPolygonsVisibility(id)).toBe(visibility);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Polygons color", () => {
     test("Color red", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const color = { r: 255, g: 0, b: 0 }
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshPolygonsColor(id, color)
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const color = { r: 255, g: 0, b: 0 };
+      const spy = vi.spyOn(viewerStore, "request");
+      const result = dataStyleStore.setMeshPolygonsColor(id, color);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_polygons_schemas.color,
         { id, color },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshPolygonsColor(id)).toStrictEqual(color)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshPolygonsColor(id)).toStrictEqual(color);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Polygons vertex attribute", () => {
     test("Coloring vertex attribute", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshPolygonsVertexAttributeName(
-        id,
-        vertex_attribute.name,
-      )
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const spy = vi.spyOn(viewerStore, "request");
+      const result = dataStyleStore.setMeshPolygonsVertexAttributeName(id, vertex_attribute.name);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_polygons_schemas.attribute.vertex.name,
         { id, ...vertex_attribute },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshPolygonsVertexAttributeName(id)).toBe(
-        vertex_attribute.name,
-      )
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshPolygonsVertexAttributeName(id)).toBe(vertex_attribute.name);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Polygons polygon attribute", () => {
     test("Coloring polygon attribute", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshPolygonsPolygonAttributeName(
-        id,
-        polygon_attribute.name,
-      )
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const spy = vi.spyOn(viewerStore, "request");
+      const result = dataStyleStore.setMeshPolygonsPolygonAttributeName(id, polygon_attribute.name);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_polygons_schemas.attribute.polygon.name,
         { id, ...polygon_attribute },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshPolygonsPolygonAttributeName(id)).toBe(
-        polygon_attribute.name,
-      )
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshPolygonsPolygonAttributeName(id)).toBe(polygon_attribute.name);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Polygons active coloring", () => {
     test("test coloring", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
       const coloringTypes = [
         { name: "color" },
         {
           name: "vertex",
           function: () =>
-            dataStyleStore.setMeshPolygonsVertexAttributeName(
-              id,
-              vertex_attribute.name,
-            ),
+            dataStyleStore.setMeshPolygonsVertexAttributeName(id, vertex_attribute.name),
         },
         {
           name: "polygon",
           function: () =>
-            dataStyleStore.setMeshPolygonsPolygonAttributeName(
-              id,
-              polygon_attribute.name,
-            ),
+            dataStyleStore.setMeshPolygonsPolygonAttributeName(id, polygon_attribute.name),
         },
-      ]
+      ];
 
       async function testColoring(coloringType, expectedColoringType) {
         if (coloringType.function) {
-          await coloringType.function()
+          await coloringType.function();
         }
-        const result = dataStyleStore.setMeshPolygonsActiveColoring(
-          id,
-          coloringType.name,
-        )
-        expect(result).toBeInstanceOf(Promise)
-        await result
-        expect(dataStyleStore.meshPolygonsActiveColoring(id)).toBe(
-          expectedColoringType,
-        )
-        expect(viewerStore.status).toBe(Status.CONNECTED)
+        const result = dataStyleStore.setMeshPolygonsActiveColoring(id, coloringType.name);
+        expect(result).toBeInstanceOf(Promise);
+        await result;
+        expect(dataStyleStore.meshPolygonsActiveColoring(id)).toBe(expectedColoringType);
+        expect(viewerStore.status).toBe(Status.CONNECTED);
       }
 
-      await testColoring(coloringTypes[0], "color")
-      await testColoring(coloringTypes[1], "vertex")
-      await testColoring(coloringTypes[2], "polygon")
-    })
-  })
+      await testColoring(coloringTypes[0], "color");
+      await testColoring(coloringTypes[1], "vertex");
+      await testColoring(coloringTypes[2], "polygon");
+    });
+  });
 
   test("Polygons apply default style", async () => {
-    const dataStyleStore = useDataStyleStore()
-    const viewerStore = useViewerStore()
-    const result = dataStyleStore.applyMeshPolygonsStyle(id)
-    expect(result).toBeInstanceOf(Promise)
-    await result
-    expect(viewerStore.status).toBe(Status.CONNECTED)
-  })
-})
+    const dataStyleStore = useDataStyleStore();
+    const viewerStore = useViewerStore();
+    const result = dataStyleStore.applyMeshPolygonsStyle(id);
+    expect(result).toBeInstanceOf(Promise);
+    await result;
+    expect(viewerStore.status).toBe(Status.CONNECTED);
+  });
+});

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

@@ -1,171 +1,147 @@
 // Third party imports
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" };
 
 // Local imports
-import { Status } from "@ogw_front/utils/status"
-import { cleanupBackend } from "@ogw_front/utils/local/cleanup"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
-import { useDataStyleStore } from "@ogw_front/stores/data_style"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { Status } from "@ogw_front/utils/status";
+import { cleanupBackend } from "@ogw_front/utils/local/cleanup";
+import { setupIntegrationTests } from "@ogw_tests/integration/setup";
+import { useDataStyleStore } from "@ogw_front/stores/data_style";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const INTERVAL_TIMEOUT = 20_000
-const mesh_polyhedra_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra
-const file_name = "test.vtu"
-const geode_object = "HybridSolid3D"
-const vertex_attribute = { name: "toto_on_vertices" }
-const polyhedron_attribute = { name: "toto_on_polyhedra" }
+const INTERVAL_TIMEOUT = 20_000;
+const mesh_polyhedra_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra;
+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 = "",
-  projectFolderPath = ""
+  projectFolderPath = "";
 
 beforeEach(async () => {
-  ;({ id, projectFolderPath } = await setupIntegrationTests(
-    file_name,
-    geode_object,
-  ))
-}, INTERVAL_TIMEOUT)
+  ({ id, projectFolderPath } = await setupIntegrationTests(file_name, geode_object));
+}, INTERVAL_TIMEOUT);
 
 afterEach(async () => {
-  console.log("afterEach mesh cells kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach mesh cells kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 
 describe("Mesh polyhedra", () => {
   describe("Polyhedra", () => {
     test("Polyhedra visibility", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const visibility = true
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshPolyhedraVisibility(id, visibility)
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const visibility = true;
+      const spy = vi.spyOn(viewerStore, "request");
+      const result = dataStyleStore.setMeshPolyhedraVisibility(id, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_polyhedra_schemas.visibility,
         { id, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshPolyhedraVisibility(id)).toBe(visibility)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
+      );
+      expect(dataStyleStore.meshPolyhedraVisibility(id)).toBe(visibility);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
 
     test("Polyhedra color red", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const color = { r: 255, g: 0, b: 0 }
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshPolyhedraColor(id, color)
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const color = { r: 255, g: 0, b: 0 };
+      const spy = vi.spyOn(viewerStore, "request");
+      const result = dataStyleStore.setMeshPolyhedraColor(id, color);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_polyhedra_schemas.color,
         { id, color },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshPolyhedraColor(id)).toStrictEqual(color)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
+      );
+      expect(dataStyleStore.meshPolyhedraColor(id)).toStrictEqual(color);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
 
     test("Polyhedra active coloring", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
       const coloringTypes = [
         { name: "color" },
         {
           name: "vertex",
           function: () =>
-            dataStyleStore.setMeshPolyhedraVertexAttributeName(
-              id,
-              vertex_attribute.name,
-            ),
+            dataStyleStore.setMeshPolyhedraVertexAttributeName(id, vertex_attribute.name),
         },
         {
           name: "polyhedron",
           function: () =>
-            dataStyleStore.setMeshPolyhedraPolyhedronAttributeName(
-              id,
-              polyhedron_attribute.name,
-            ),
+            dataStyleStore.setMeshPolyhedraPolyhedronAttributeName(id, polyhedron_attribute.name),
         },
-      ]
+      ];
       async function testColoring(coloringType, expectedColoringType) {
         if (coloringType.function) {
-          await coloringType.function()
+          await coloringType.function();
         }
-        const result = dataStyleStore.setMeshPolyhedraActiveColoring(
-          id,
-          coloringType.name,
-        )
-        expect(result).toBeInstanceOf(Promise)
-        await result
-        expect(dataStyleStore.meshPolyhedraActiveColoring(id)).toBe(
-          expectedColoringType,
-        )
-        expect(viewerStore.status).toBe(Status.CONNECTED)
+        const result = dataStyleStore.setMeshPolyhedraActiveColoring(id, coloringType.name);
+        expect(result).toBeInstanceOf(Promise);
+        await result;
+        expect(dataStyleStore.meshPolyhedraActiveColoring(id)).toBe(expectedColoringType);
+        expect(viewerStore.status).toBe(Status.CONNECTED);
       }
 
-      await testColoring(coloringTypes[0], "color")
-      await testColoring(coloringTypes[1], "vertex")
-      await testColoring(coloringTypes[2], "polyhedron")
-    })
-  })
+      await testColoring(coloringTypes[0], "color");
+      await testColoring(coloringTypes[1], "vertex");
+      await testColoring(coloringTypes[2], "polyhedron");
+    });
+  });
 
   test("Polyhedra vertex attribute", async () => {
-    const dataStyleStore = useDataStyleStore()
-    const viewerStore = useViewerStore()
+    const dataStyleStore = useDataStyleStore();
+    const viewerStore = useViewerStore();
 
-    const spy = vi.spyOn(viewerStore, "request")
-    await dataStyleStore.setMeshPolyhedraVertexAttributeName(
-      id,
-      vertex_attribute.name,
-    )
+    const spy = vi.spyOn(viewerStore, "request");
+    await dataStyleStore.setMeshPolyhedraVertexAttributeName(id, vertex_attribute.name);
     expect(spy).toHaveBeenCalledWith(
       mesh_polyhedra_schemas.attribute.vertex.name,
       { id, ...vertex_attribute },
       {
         response_function: expect.any(Function),
       },
-    )
-    expect(dataStyleStore.meshPolyhedraVertexAttributeName(id)).toBe(
-      vertex_attribute.name,
-    )
-    expect(viewerStore.status).toBe(Status.CONNECTED)
-  })
+    );
+    expect(dataStyleStore.meshPolyhedraVertexAttributeName(id)).toBe(vertex_attribute.name);
+    expect(viewerStore.status).toBe(Status.CONNECTED);
+  });
 
   test("Polyhedra polyhedron attribute", async () => {
-    const dataStyleStore = useDataStyleStore()
-    const viewerStore = useViewerStore()
+    const dataStyleStore = useDataStyleStore();
+    const viewerStore = useViewerStore();
 
-    const spy = vi.spyOn(viewerStore, "request")
-    await dataStyleStore.setMeshPolyhedraPolyhedronAttributeName(
-      id,
-      polyhedron_attribute.name,
-    )
+    const spy = vi.spyOn(viewerStore, "request");
+    await dataStyleStore.setMeshPolyhedraPolyhedronAttributeName(id, polyhedron_attribute.name);
     expect(spy).toHaveBeenCalledWith(
       mesh_polyhedra_schemas.attribute.polyhedron.name,
       { id, ...polyhedron_attribute },
       {
         response_function: expect.any(Function),
       },
-    )
-    expect(dataStyleStore.meshPolyhedraPolyhedronAttributeName(id)).toBe(
-      polyhedron_attribute.name,
-    )
-    expect(viewerStore.status).toBe(Status.CONNECTED)
-  })
+    );
+    expect(dataStyleStore.meshPolyhedraPolyhedronAttributeName(id)).toBe(polyhedron_attribute.name);
+    expect(viewerStore.status).toBe(Status.CONNECTED);
+  });
 
   test("Polyhedra apply default style", async () => {
-    const dataStyleStore = useDataStyleStore()
-    const viewerStore = useViewerStore()
-    const result = dataStyleStore.applyMeshPolyhedraStyle(id)
-    expect(result).toBeInstanceOf(Promise)
-    await result
-    expect(viewerStore.status).toBe(Status.CONNECTED)
-  })
-})
+    const dataStyleStore = useDataStyleStore();
+    const viewerStore = useViewerStore();
+    const result = dataStyleStore.applyMeshPolyhedraStyle(id);
+    expect(result).toBeInstanceOf(Promise);
+    await result;
+    expect(viewerStore.status).toBe(Status.CONNECTED);
+  });
+});