@geode/opengeodeweb-front 9.12.2-rc.1 → 9.12.2-rc.2

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

@@ -1,5 +1,3 @@
-// Node.js imports
-
 // 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" }
@@ -9,26 +7,30 @@ import Status from "~/utils/status"
 import * as composables from "~/composables/viewer_call"
 import { useDataStyleStore } from "~/stores/data_style"
 import { useViewerStore } from "~/stores/viewer"
-import { kill_back, kill_viewer } from "~/utils/local"
+import { delete_folder_recursive, kill_back, kill_viewer } from "~/utils/local"
 import { setupIntegrationTests } from "../../../setup.js"
 
 // Local constants
 const mesh_points_schemas = viewer_schemas.opengeodeweb_viewer.mesh.points
-let id, back_port, viewer_port
 const file_name = "test.og_edc2d"
 const geode_object = "EdgedCurve2D"
-const object_type = "mesh"
+
+let id, back_port, viewer_port, project_folder_path
 
 beforeEach(async () => {
-  ;({ id, back_port, viewer_port } = await setupIntegrationTests(
-    file_name,
-    geode_object,
-    object_type,
-  ))
+  ;({ id, back_port, viewer_port, project_folder_path } =
+    await setupIntegrationTests(file_name, geode_object))
 }, 20000)
 
 afterEach(async () => {
+  console.log(
+    "afterEach mesh points kill",
+    back_port,
+    viewer_port,
+    project_folder_path,
+  )
   await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+  delete_folder_recursive(project_folder_path)
 })
 
 describe("Mesh points", () => {
@@ -36,8 +38,19 @@ describe("Mesh points", () => {
     test("Visibility true", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      await dataStyleStore.setMeshPointsVisibility(id, true)
-      expect(dataStyleStore.meshPointsVisibility(id)).toBe(true)
+      const visibility = true
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setMeshPointsVisibility(id, visibility)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: mesh_points_schemas.visibility,
+          params: { id, visibility },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.meshPointsVisibility(id)).toBe(visibility)
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
   })
@@ -57,7 +70,7 @@ describe("Mesh points", () => {
     })
   })
   describe("Points color", () => {
-    test("test red", async () => {
+    test("Color red", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const color = { r: 255, g: 0, b: 0 }
@@ -76,4 +89,25 @@ describe("Mesh points", () => {
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
   })
+
+  describe("Points size", () => {
+    test("Size 20", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const size = 20
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setMeshPointsSize(id, size)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: mesh_points_schemas.size,
+          params: { id, size },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.meshPointsSize(id)).toBe(size)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
 })

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

@@ -1,5 +1,3 @@
-// Node.js imports
-
 // 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" }
@@ -9,26 +7,31 @@ import Status from "~/utils/status"
 import * as composables from "~/composables/viewer_call"
 import { useDataStyleStore } from "~/stores/data_style"
 import { useViewerStore } from "~/stores/viewer"
-import { kill_back, kill_viewer } from "~/utils/local"
+import { delete_folder_recursive, kill_back, kill_viewer } from "~/utils/local"
 import { setupIntegrationTests } from "../../../setup.js"
 
 // Local constants
 const mesh_polygons_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polygons
-let id, back_port, viewer_port
 const file_name = "test.og_psf3d"
 const geode_object = "PolygonalSurface3D"
-const object_type = "mesh"
+
+let id, back_port, viewer_port, project_folder_path
 
 beforeEach(async () => {
-  ;({ id, back_port, viewer_port } = await setupIntegrationTests(
-    file_name,
-    geode_object,
-    object_type,
-  ))
+  ;({ id, back_port, viewer_port, project_folder_path } =
+    await setupIntegrationTests(file_name, geode_object))
 }, 20000)
 
 afterEach(async () => {
+  console.log(
+    "afterEach mesh polygons kill",
+    back_port,
+    viewer_port,
+    project_folder_path,
+  )
+
   await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+  delete_folder_recursive(project_folder_path)
 })
 
 describe("Mesh polygons", () => {
@@ -36,8 +39,19 @@ describe("Mesh polygons", () => {
     test("Visibility true", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      await dataStyleStore.setMeshPolygonsVisibility(id, true)
-      expect(dataStyleStore.meshPolygonsVisibility(id)).toBe(true)
+      const visibility = true
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setMeshPolygonsVisibility(id, visibility)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: mesh_polygons_schemas.visibility,
+          params: { id, visibility },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.meshPolygonsVisibility(id)).toBe(visibility)
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
   })
@@ -56,7 +70,7 @@ describe("Mesh polygons", () => {
     })
   })
   describe("Polygons color", () => {
-    test("test red", async () => {
+    test("Color red", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const color = { r: 255, g: 0, b: 0 }

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

@@ -1,5 +1,3 @@
-// Node.js imports
-
 // 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" }
@@ -9,26 +7,30 @@ import Status from "~/utils/status"
 import * as composables from "~/composables/viewer_call"
 import { useDataStyleStore } from "~/stores/data_style"
 import { useViewerStore } from "~/stores/viewer"
-import { kill_back, kill_viewer } from "~/utils/local"
+import { delete_folder_recursive, kill_back, kill_viewer } from "~/utils/local"
 import { setupIntegrationTests } from "../../../setup.js"
 
 // Local constants
 const mesh_polyhedra_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra
-let id, back_port, viewer_port
 const file_name = "test.og_rgd3d"
 const geode_object = "RegularGrid3D"
-const object_type = "mesh"
+
+let id, back_port, viewer_port, project_folder_path
 
 beforeEach(async () => {
-  ;({ id, back_port, viewer_port } = await setupIntegrationTests(
-    file_name,
-    geode_object,
-    object_type,
-  ))
+  ;({ id, back_port, viewer_port, project_folder_path } =
+    await setupIntegrationTests(file_name, geode_object))
 }, 20000)
 
 afterEach(async () => {
+  console.log(
+    "afterEach mesh polyhedra kill",
+    back_port,
+    viewer_port,
+    project_folder_path,
+  )
   await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+  delete_folder_recursive(project_folder_path)
 })
 
 describe("Mesh polyhedra", () => {
@@ -36,8 +38,19 @@ describe("Mesh polyhedra", () => {
     test("Visibility true", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      await dataStyleStore.setMeshPolyhedraVisibility(id, true)
-      expect(dataStyleStore.meshPolyhedraVisibility(id)).toBe(true)
+      const visibility = true
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setMeshPolyhedraVisibility(id, visibility)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: mesh_polyhedra_schemas.visibility,
+          params: { id, visibility },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.meshPolyhedraVisibility(id)).toBe(visibility)
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
   })
@@ -56,7 +69,7 @@ describe("Mesh polyhedra", () => {
     })
   })
   describe("Polyhedra color", () => {
-    test("test red", async () => {
+    test("Color red", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const color = { r: 255, g: 0, b: 0 }

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

@@ -0,0 +1,92 @@
+// 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" }
+
+// Local imports
+import Status from "~/utils/status"
+import * as composables from "~/composables/viewer_call"
+import { useDataStyleStore } from "~/stores/data_style"
+import { useViewerStore } from "~/stores/viewer"
+import { delete_folder_recursive, kill_back, kill_viewer } from "~/utils/local"
+import { setupIntegrationTests } from "../../../setup.js"
+
+// Local constants
+const model_blocks_schemas = viewer_schemas.opengeodeweb_viewer.model.blocks
+const file_name = "test.og_brep"
+const geode_object = "BRep"
+
+let id, back_port, viewer_port, project_folder_path
+
+beforeEach(async () => {
+  ;({ id, back_port, viewer_port, project_folder_path } =
+    await setupIntegrationTests(file_name, geode_object))
+}, 20000)
+
+afterEach(async () => {
+  console.log(
+    "afterEach model blocks kill",
+    back_port,
+    viewer_port,
+    project_folder_path,
+  )
+  await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+  delete_folder_recursive(project_folder_path)
+})
+
+describe("Model blocks", () => {
+  describe("Blocks visibility", () => {
+    test("Visibility false", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const dataBaseStore = useDataBaseStore()
+      const block_ids = dataBaseStore.getBlocksUuids(id)
+      const block_flat_indexes = dataBaseStore.getFlatIndexes(id, block_ids)
+      const visibility = false
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setModelBlocksVisibility(id, block_ids, visibility)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_blocks_schemas.visibility,
+          params: { id, block_ids: block_flat_indexes, visibility },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      for (const block_id of block_ids) {
+        expect(dataStyleStore.modelBlockVisibility(id, block_id)).toBe(
+          visibility,
+        )
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+
+  describe("Blocks color", () => {
+    test("Color red", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const dataBaseStore = useDataBaseStore()
+      const block_ids = dataBaseStore.getBlocksUuids(id)
+      const block_flat_indexes = dataBaseStore.getFlatIndexes(id, block_ids)
+      const color = { r: 255, g: 0, b: 0 }
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setModelBlocksColor(id, block_ids, color)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_blocks_schemas.color,
+          params: { id, block_ids: block_flat_indexes, color },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      for (const block_id of block_ids) {
+        expect(dataStyleStore.modelBlockColor(id, block_id)).toStrictEqual(
+          color,
+        )
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+})

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

@@ -0,0 +1,92 @@
+// 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" }
+
+// Local imports
+import Status from "~/utils/status"
+import * as composables from "~/composables/viewer_call"
+import { useDataStyleStore } from "~/stores/data_style"
+import { useViewerStore } from "~/stores/viewer"
+import { delete_folder_recursive, kill_back, kill_viewer } from "~/utils/local"
+import { setupIntegrationTests } from "../../../setup.js"
+
+// Local constants
+const model_corners_schemas = viewer_schemas.opengeodeweb_viewer.model.corners
+const file_name = "test.og_brep"
+const geode_object = "BRep"
+
+let id, back_port, viewer_port, project_folder_path
+
+beforeEach(async () => {
+  ;({ id, back_port, viewer_port, project_folder_path } =
+    await setupIntegrationTests(file_name, geode_object))
+}, 20000)
+
+afterEach(async () => {
+  console.log(
+    "afterEach model corners kill",
+    back_port,
+    viewer_port,
+    project_folder_path,
+  )
+  await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+  delete_folder_recursive(project_folder_path)
+})
+
+describe("Model corners", () => {
+  describe("Corners visibility", () => {
+    test("Visibility false", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const dataBaseStore = useDataBaseStore()
+      const corner_ids = dataBaseStore.getCornersUuids(id)
+      const corner_flat_indexes = dataBaseStore.getFlatIndexes(id, corner_ids)
+      const visibility = false
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setModelCornersVisibility(id, corner_ids, visibility)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_corners_schemas.visibility,
+          params: { id, block_ids: corner_flat_indexes, visibility },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      for (const corner_id of corner_ids) {
+        expect(dataStyleStore.modelCornerVisibility(id, corner_id)).toBe(
+          visibility,
+        )
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+
+  describe("Corner color", () => {
+    test("Color red", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const dataBaseStore = useDataBaseStore()
+      const corner_ids = dataBaseStore.getCornersUuids(id)
+      const corner_flat_indexes = dataBaseStore.getFlatIndexes(id, corner_ids)
+      const color = { r: 255, g: 0, b: 0 }
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setModelCornersColor(id, corner_ids, color)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_corners_schemas.color,
+          params: { id, block_ids: corner_flat_indexes, color },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      for (const corner_id of corner_ids) {
+        expect(dataStyleStore.modelCornerColor(id, corner_id)).toStrictEqual(
+          color,
+        )
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+})

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

@@ -0,0 +1,57 @@
+// 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" }
+
+// Local imports
+import Status from "~/utils/status"
+import * as composables from "~/composables/viewer_call"
+import { useDataStyleStore } from "~/stores/data_style"
+import { useViewerStore } from "~/stores/viewer"
+import { delete_folder_recursive, kill_back, kill_viewer } from "~/utils/local"
+import { setupIntegrationTests } from "../../../setup.js"
+
+// Local constants
+const model_edges_schemas = viewer_schemas.opengeodeweb_viewer.model.edges
+const file_name = "test.og_brep"
+const geode_object = "BRep"
+
+let id, back_port, viewer_port, project_folder_path
+
+beforeEach(async () => {
+  ;({ id, back_port, viewer_port, project_folder_path } =
+    await setupIntegrationTests(file_name, geode_object))
+}, 25000)
+
+afterEach(async () => {
+  console.log(
+    "afterEach model edges kill",
+    back_port,
+    viewer_port,
+    project_folder_path,
+  )
+  await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+  delete_folder_recursive(project_folder_path)
+})
+
+describe("Model edges", () => {
+  describe("Edges visibility", () => {
+    test("Visibility true", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const visibility = true
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setModelEdgesVisibility(id, visibility)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_edges_schemas.visibility,
+          params: { id, visibility },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.modelEdgesVisibility(id)).toBe(visibility)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+})

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

@@ -0,0 +1,57 @@
+// 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" }
+
+// Local imports
+import Status from "~/utils/status"
+import * as composables from "~/composables/viewer_call"
+import { useDataStyleStore } from "~/stores/data_style"
+import { useViewerStore } from "~/stores/viewer"
+import { delete_folder_recursive, kill_back, kill_viewer } from "~/utils/local"
+import { setupIntegrationTests } from "../../../setup.js"
+
+// Local constants
+const model_schemas = viewer_schemas.opengeodeweb_viewer.model
+const file_name = "test.og_brep"
+const geode_object = "BRep"
+
+let id, back_port, viewer_port, project_folder_path
+
+beforeEach(async () => {
+  ;({ id, back_port, viewer_port, project_folder_path } =
+    await setupIntegrationTests(file_name, geode_object))
+}, 20000)
+
+afterEach(async () => {
+  console.log(
+    "afterEach model kill",
+    back_port,
+    viewer_port,
+    project_folder_path,
+  )
+  await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+  delete_folder_recursive(project_folder_path)
+})
+
+describe("Model", () => {
+  describe("Model visibility", () => {
+    test("Visibility true", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const visibility = true
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setModelVisibility(id, visibility)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_schemas.visibility,
+          params: { id, visibility },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.modelVisibility(id)).toBe(visibility)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+})

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

@@ -0,0 +1,83 @@
+// 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" }
+
+// Local imports
+import Status from "~/utils/status"
+import * as composables from "~/composables/viewer_call"
+import { useDataStyleStore } from "~/stores/data_style"
+import { useViewerStore } from "~/stores/viewer"
+import { setupIntegrationTests } from "../../../setup.js"
+
+// Local constants
+const model_lines_schemas = viewer_schemas.opengeodeweb_viewer.model.lines
+const file_name = "test.og_brep"
+const geode_object = "BRep"
+
+let id, back_port, viewer_port, project_folder_path
+
+beforeEach(async () => {
+  ;({ id, back_port, viewer_port, project_folder_path } =
+    await setupIntegrationTests(file_name, geode_object))
+}, 20000)
+
+afterEach(async () => {
+  console.log("afterEach model lines kill", back_port, viewer_port)
+  await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+  delete_folder_recursive(project_folder_path)
+})
+
+describe("Model lines", () => {
+  describe("Lines visibility", () => {
+    test("Visibility false", async () => {
+      console.log("FROM TEST MODEL LINES")
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const dataBaseStore = useDataBaseStore()
+      const line_ids = dataBaseStore.getLinesUuids(id)
+      const lines_flat_indexes = dataBaseStore.getFlatIndexes(id, line_ids)
+      const visibility = false
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setModelLinesVisibility(id, line_ids, visibility)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_lines_schemas.visibility,
+          params: { id, block_ids: lines_flat_indexes, visibility },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      for (const line_id of line_ids) {
+        expect(dataStyleStore.modelLineVisibility(id, line_id)).toBe(visibility)
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+
+  describe("Lines color", () => {
+    test("Color red", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const dataBaseStore = useDataBaseStore()
+      const line_ids = dataBaseStore.getLinesUuids(id)
+      const lines_flat_indexes = dataBaseStore.getFlatIndexes(id, line_ids)
+      const color = { r: 255, g: 0, b: 0 }
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setModelLinesColor(id, line_ids, color)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_lines_schemas.color,
+          params: { id, block_ids: lines_flat_indexes, color },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      for (const line_id of line_ids) {
+        expect(dataStyleStore.modelLineColor(id, line_id)).toStrictEqual(color)
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+})