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

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

@@ -1,170 +1,144 @@
 // 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 = 25_000
-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" }
+const INTERVAL_TIMEOUT = 25_000;
+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 = "",
-  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 edges kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach mesh edges kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 
 describe("Mesh edges", () => {
   describe("Edges", () => {
     test("Edges visibility", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const visibility = true
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshEdgesVisibility(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.setMeshEdgesVisibility(id, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_edges_schemas.visibility,
         { id, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshEdgesVisibility(id)).toBe(visibility)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
+      );
+      expect(dataStyleStore.meshEdgesVisibility(id)).toBe(visibility);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
 
     test("Edges 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.setMeshEdgesColor(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.setMeshEdgesColor(id, color);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_edges_schemas.color,
         { id, color },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshEdgesColor(id)).toStrictEqual(color)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
+      );
+      expect(dataStyleStore.meshEdgesColor(id)).toStrictEqual(color);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
 
     test("Edges vertex attribute", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
 
-      const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshEdgesVertexAttributeName(
-        id,
-        vertex_attribute.name,
-      )
+      const spy = vi.spyOn(viewerStore, "request");
+      await dataStyleStore.setMeshEdgesVertexAttributeName(id, vertex_attribute.name);
       expect(spy).toHaveBeenCalledWith(
         mesh_edges_schemas.attribute.vertex.name,
         { id, ...vertex_attribute },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshEdgesVertexAttributeName(id)).toBe(
-        vertex_attribute.name,
-      )
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
+      );
+      expect(dataStyleStore.meshEdgesVertexAttributeName(id)).toBe(vertex_attribute.name);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
 
     test("Edges edge attribute", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
 
-      const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshEdgesEdgeAttributeName(
-        id,
-        edge_attribute.name,
-      )
+      const spy = vi.spyOn(viewerStore, "request");
+      await dataStyleStore.setMeshEdgesEdgeAttributeName(id, edge_attribute.name);
       expect(spy).toHaveBeenCalledWith(
         mesh_edges_schemas.attribute.edge.name,
         { id, ...edge_attribute },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshEdgesEdgeAttributeName(id)).toBe(
-        edge_attribute.name,
-      )
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
+      );
+      expect(dataStyleStore.meshEdgesEdgeAttributeName(id)).toBe(edge_attribute.name);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
 
     test("Edges active coloring", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
       const coloringTypes = [
         { name: "color" },
         {
           name: "vertex",
-          function: () =>
-            dataStyleStore.setMeshEdgesVertexAttributeName(
-              id,
-              vertex_attribute.name,
-            ),
+          function: () => dataStyleStore.setMeshEdgesVertexAttributeName(id, vertex_attribute.name),
         },
         {
           name: "edge",
-          function: () =>
-            dataStyleStore.setMeshEdgesEdgeAttributeName(
-              id,
-              edge_attribute.name,
-            ),
+          function: () => dataStyleStore.setMeshEdgesEdgeAttributeName(id, edge_attribute.name),
         },
-      ]
+      ];
       async function testColoring(coloringType) {
         if (coloringType.function) {
-          await coloringType.function()
+          await coloringType.function();
         }
-        const result = dataStyleStore.setMeshEdgesActiveColoring(
-          id,
-          coloringType.name,
-        )
-        expect(result).toBeInstanceOf(Promise)
-        await result
-        expect(dataStyleStore.meshEdgesActiveColoring(id)).toBe(
-          coloringType.name,
-        )
-        expect(viewerStore.status).toBe(Status.CONNECTED)
+        const result = dataStyleStore.setMeshEdgesActiveColoring(id, coloringType.name);
+        expect(result).toBeInstanceOf(Promise);
+        await result;
+        expect(dataStyleStore.meshEdgesActiveColoring(id)).toBe(coloringType.name);
+        expect(viewerStore.status).toBe(Status.CONNECTED);
       }
 
-      await testColoring(coloringTypes[0])
-      await testColoring(coloringTypes[1])
-      await testColoring(coloringTypes[2])
-    })
+      await testColoring(coloringTypes[0]);
+      await testColoring(coloringTypes[1]);
+      await testColoring(coloringTypes[2]);
+    });
     test("Edges apply style", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const result = dataStyleStore.applyMeshEdgesStyle(id)
-      expect(result).toBeInstanceOf(Promise)
-      await result
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
-})
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const result = dataStyleStore.applyMeshEdgesStyle(id);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+});

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

@@ -1,65 +1,62 @@
 // 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_schemas = viewer_schemas.opengeodeweb_viewer.mesh
-const file_name = "test.og_rgd3d"
-const geode_object = "RegularGrid3D"
+const INTERVAL_TIMEOUT = 20_000;
+const mesh_schemas = viewer_schemas.opengeodeweb_viewer.mesh;
+const file_name = "test.og_rgd3d";
+const geode_object = "RegularGrid3D";
 
 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 index kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach mesh index kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 
 describe("Mesh", () => {
   describe("Mesh visibility", () => {
     test("Visibility true", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const visibility = true
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshVisibility(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.setMeshVisibility(id, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_schemas.visibility,
         { id, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshVisibility(id)).toBe(visibility)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshVisibility(id)).toBe(visibility);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Apply mesh default style", () => {
     test("Apply mesh default style", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const result = dataStyleStore.applyMeshStyle(id)
-      expect(result).toBeInstanceOf(Promise)
-      await result
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
-})
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      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

@@ -1,166 +1,150 @@
 // 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_points_schemas = viewer_schemas.opengeodeweb_viewer.mesh.points
-const file_name = "test.og_edc2d"
-const geode_object = "EdgedCurve2D"
-const vertex_attribute = { name: "points" }
+const INTERVAL_TIMEOUT = 20_000;
+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 = "",
-  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 points kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach mesh points kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 
 describe("Mesh points", () => {
   describe("Points visibility", () => {
     test("Visibility true", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const visibility = true
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshPointsVisibility(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.setMeshPointsVisibility(id, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_points_schemas.visibility,
         { id, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshPointsVisibility(id)).toBe(visibility)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshPointsVisibility(id)).toBe(visibility);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Points 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.setMeshPointsColor(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.setMeshPointsColor(id, color);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_points_schemas.color,
         { id, color },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshPointsColor(id)).toStrictEqual(color)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshPointsColor(id)).toStrictEqual(color);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Points 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.setMeshPointsVertexAttributeName(
-              id,
-              vertex_attribute.name,
-            ),
+            dataStyleStore.setMeshPointsVertexAttributeName(id, vertex_attribute.name),
         },
-      ]
+      ];
       async function testColoring(coloringType, expectedColoringType) {
         if (coloringType.function) {
-          await coloringType.function()
+          await coloringType.function();
         }
-        const result = dataStyleStore.setMeshPointsActiveColoring(
-          id,
-          coloringType.name,
-        )
-        expect(result).toBeInstanceOf(Promise)
-        await result
-        expect(dataStyleStore.meshPointsActiveColoring(id)).toBe(
-          expectedColoringType,
-        )
-        expect(viewerStore.status).toBe(Status.CONNECTED)
+        const result = dataStyleStore.setMeshPointsActiveColoring(id, coloringType.name);
+        expect(result).toBeInstanceOf(Promise);
+        await result;
+        expect(dataStyleStore.meshPointsActiveColoring(id)).toBe(expectedColoringType);
+        expect(viewerStore.status).toBe(Status.CONNECTED);
       }
 
-      await testColoring(coloringTypes[0], "color")
-      await testColoring(coloringTypes[1], "vertex")
-    })
-  })
+      await testColoring(coloringTypes[0], "color");
+      await testColoring(coloringTypes[1], "vertex");
+    });
+  });
 
   describe("Points size", () => {
     test("Size 20", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const size = 20
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshPointsSize(id, size)
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const size = 20;
+      const spy = vi.spyOn(viewerStore, "request");
+      const result = dataStyleStore.setMeshPointsSize(id, size);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_points_schemas.size,
         { id, size },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshPointsSize(id)).toBe(size)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshPointsSize(id)).toBe(size);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Points vertex attribute", () => {
     test("test coloring", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
 
-      const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setMeshPointsVertexAttributeName(
-        id,
-        vertex_attribute.name,
-      )
+      const spy = vi.spyOn(viewerStore, "request");
+      await dataStyleStore.setMeshPointsVertexAttributeName(id, vertex_attribute.name);
       expect(spy).toHaveBeenCalledWith(
         mesh_points_schemas.attribute.vertex.name,
         { id, ...vertex_attribute },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshPointsVertexAttributeName(id)).toBe(
-        vertex_attribute.name,
-      )
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshPointsVertexAttributeName(id)).toBe(vertex_attribute.name);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   test("Points apply default style", async () => {
-    const dataStyleStore = useDataStyleStore()
-    const viewerStore = useViewerStore()
-    const result = dataStyleStore.applyMeshPointsStyle(id)
-    expect(result).toBeInstanceOf(Promise)
-    await result
-    expect(viewerStore.status).toBe(Status.CONNECTED)
-  })
-})
+    const dataStyleStore = useDataStyleStore();
+    const viewerStore = useViewerStore();
+    const result = dataStyleStore.applyMeshPointsStyle(id);
+    expect(result).toBeInstanceOf(Promise);
+    await result;
+    expect(viewerStore.status).toBe(Status.CONNECTED);
+  });
+});