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

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

@@ -0,0 +1,73 @@
+// 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_points_schemas = viewer_schemas.opengeodeweb_viewer.model.points
+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 points kill", back_port, viewer_port)
+  await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+  delete_folder_recursive(project_folder_path)
+})
+
+describe("Model points", () => {
+  describe("Points visibility", () => {
+    test("Visibility true", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const visibility = true
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setModelPointsVisibility(id, visibility)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_points_schemas.visibility,
+          params: { id, visibility },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.modelPointsVisibility(id)).toBe(visibility)
+      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.setModelPointsSize(id, size)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_points_schemas.size,
+          params: { id, size },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.modelPointsSize(id)).toBe(size)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+})

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

@@ -0,0 +1,96 @@
+// 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_surfaces_schemas = viewer_schemas.opengeodeweb_viewer.model.surfaces
+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 surfaces 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 surfaces", () => {
+  describe("Surfaces visibility", () => {
+    test("Visibility true", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const dataBaseStore = useDataBaseStore()
+      const surface_ids = dataBaseStore.getSurfacesUuids(id)
+      const surface_flat_indexes = dataBaseStore.getFlatIndexes(id, surface_ids)
+      const visibility = true
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setModelSurfacesVisibility(
+        id,
+        surface_ids,
+        visibility,
+      )
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_surfaces_schemas.visibility,
+          params: { id, block_ids: surface_flat_indexes, visibility },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      for (const surface_id of surface_ids) {
+        expect(dataStyleStore.modelSurfaceVisibility(id, surface_id)).toBe(
+          visibility,
+        )
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+
+  describe("Surfaces color", () => {
+    test("Color red", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const dataBaseStore = useDataBaseStore()
+      const surface_ids = dataBaseStore.getSurfacesUuids(id)
+      const surface_flat_indexes = dataBaseStore.getFlatIndexes(id, surface_ids)
+      const color = { r: 255, g: 0, b: 0 }
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setModelSurfacesColor(id, surface_ids, color)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: model_surfaces_schemas.color,
+          params: { id, block_ids: surface_flat_indexes, color },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      for (const surface_id of surface_ids) {
+        expect(dataStyleStore.modelSurfaceColor(id, surface_id)).toStrictEqual(
+          color,
+        )
+      }
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+})

package/tests/vitest.config.js

@@ -20,8 +20,9 @@ export default defineConfig({
         test: {
           name: "integration",
           include: ["tests/integration/**/*.test.js"],
-          setupFiles: ["tests/integration/setup.js"],
           environment: "nuxt",
+          fileParallelism: false,
+          setupFiles: ["tests/integration/setup.js"],
           server: {
             deps: {
               inline: ["vuetify"],

package/utils/default_styles.js

@@ -12,10 +12,13 @@ const polygons_defaultColor = { r: 255, g: 255, b: 255 }
 const polyhedra_defaultColor = { r: 255, g: 255, b: 255 }
 
 const corners_defaultVisibility = true
+const corners_defaultColor = { r: 20, g: 20, b: 20 }
 const lines_defaultVisibility = true
+const lines_defaultColor = { r: 20, g: 20, b: 20 }
 const surfaces_defaultVisibility = true
+const surfaces_defaultColor = { r: 20, g: 20, b: 20 }
 const blocks_defaultVisibility = true
-const lines_defaultColor = { r: 20, g: 20, b: 20 }
+const blocks_defaultColor = { r: 20, g: 20, b: 20 }
 
 // Mesh functions
 const meshPointsDefaultStyle = (
@@ -115,8 +118,11 @@ const solid_defaultStyle = () => {
 }
 
 // Model functions
-const modelCornersDefaultStyle = (visibility = corners_defaultVisibility) => {
-  return { visibility }
+const modelCornersDefaultStyle = (
+  visibility = corners_defaultVisibility,
+  color = corners_defaultColor,
+) => {
+  return { visibility, color }
 }
 const modelLinesDefaultStyle = (
   visibility = lines_defaultVisibility,
@@ -124,11 +130,17 @@ const modelLinesDefaultStyle = (
 ) => {
   return { visibility, color }
 }
-const modelSurfacesDefaultStyle = (visibility = surfaces_defaultVisibility) => {
-  return { visibility }
+const modelSurfacesDefaultStyle = (
+  visibility = surfaces_defaultVisibility,
+  color = surfaces_defaultColor,
+) => {
+  return { visibility, color }
 }
-const modelBlocksDefaultStyle = (visibility = blocks_defaultVisibility) => {
-  return { visibility }
+const modelBlocksDefaultStyle = (
+  visibility = blocks_defaultVisibility,
+  color = blocks_defaultColor,
+) => {
+  return { visibility, color }
 }
 const modelPointsDefaultStyle = (
   visibility = points_defaultVisibility,

package/utils/file_import_workflow.js

@@ -0,0 +1,82 @@
+// Third party imports
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+import { useHybridViewerStore } from "../stores/hybrid_viewer"
+
+// Local imports
+
+async function importWorkflow(files) {
+  console.log("importWorkflow", { files })
+  const promise_array = []
+  for (const file of files) {
+    const { filename, geode_object } = file
+    console.log({ filename }, { geode_object })
+    promise_array.push(importFile(filename, geode_object))
+  }
+  return Promise.all(promise_array)
+}
+
+async function importFile(filename, geode_object) {
+  const dataBaseStore = useDataBaseStore()
+  const dataStyleStore = useDataStyleStore()
+  const hybridViewerStore = useHybridViewerStore()
+  const treeviewStore = useTreeviewStore()
+  const { data } = await api_fetch({
+    schema: back_schemas.opengeodeweb_back.save_viewable_file,
+    params: {
+      input_geode_object: geode_object,
+      filename: filename,
+    },
+  })
+
+  const {
+    id,
+    native_file_name,
+    viewable_file_name,
+    name,
+    object_type,
+    binary_light_viewable,
+  } = data._value
+
+  console.log("data._value", data._value)
+
+  console.log("data._value.id", data._value.id)
+  await dataBaseStore.registerObject(data._value.id)
+  console.log("after dataBaseStore.registerObject")
+  await dataBaseStore.addItem(id, {
+    object_type: object_type,
+    geode_object: geode_object,
+    native_filename: native_file_name,
+    viewable_filename: viewable_file_name,
+    displayed_name: name,
+    vtk_js: {
+      binary_light_viewable,
+    },
+  })
+
+  await treeviewStore.addItem(geode_object, name, id, object_type)
+
+  console.log("after treeviewStore.addItem")
+
+  await hybridViewerStore.addItem(id)
+  console.log("after dataBaseStore.addItem")
+
+  await dataStyleStore.addDataStyle(
+    data._value.id,
+    data._value.geode_object,
+    data._value.object_type,
+  )
+  console.log("after dataStyleStore.addDataStyle")
+  if (data._value.object_type === "model") {
+    await Promise.all([
+      dataBaseStore.fetchMeshComponents(id),
+      dataBaseStore.fetchUuidToFlatIndexDict(id),
+    ])
+    console.log("after dataBaseStore.fetchMeshComponents")
+    console.log("after dataBaseStore.fetchUuidToFlatIndexDict")
+  }
+  await dataStyleStore.applyDefaultStyle(id)
+  console.log("after dataStyleStore.applyDefaultStyle")
+  return data._value.id
+}
+
+export { importFile, importWorkflow }

package/tests/integration/utils.js

@@ -1,35 +0,0 @@
-// Node.js imports
-import fs from "fs"
-import path from "path"
-
-function getCurrentFolders(dataFolderPath) {
-  if (!fs.existsSync(dataFolderPath)) {
-    return new Set()
-  }
-  const entries = fs.readdirSync(dataFolderPath)
-  const folders = new Set()
-  for (const entry of entries) {
-    const entryPath = path.join(dataFolderPath, entry)
-    if (fs.statSync(entryPath).isDirectory()) {
-      folders.add(entry)
-    }
-  }
-  return folders
-}
-
-function cleanupCreatedFolders(dataFolderPath, foldersBeforeTests) {
-  if (!fs.existsSync(dataFolderPath)) {
-    return
-  }
-  const currentFolders = getCurrentFolders(dataFolderPath)
-  console.log("getCurrentFolders currentFolders", currentFolders)
-  for (const folder of currentFolders) {
-    if (!foldersBeforeTests.has(folder)) {
-      const folderPath = path.join(dataFolderPath, folder)
-      fs.rmSync(folderPath, { recursive: true, force: true })
-      console.log(`Deleted folder: ${folderPath}`)
-    }
-  }
-}
-
-export { getCurrentFolders, cleanupCreatedFolders }