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

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/utils/local.js

@@ -57,8 +57,17 @@ function get_available_port() {
   })
 }
 
+function commandExistsSync(executable_name) {
+  const envPath = process.env.PATH || ""
+  return envPath.split(path.delimiter).some((dir) => {
+    const filePath = path.join(dir, executable_name)
+    return fs.existsSync(filePath) && fs.statSync(filePath).isFile()
+  })
+}
+
 async function run_script(
-  command,
+  executable_name,
+  executable_path,
   args,
   expected_response,
   timeout_seconds = 30,
@@ -68,6 +77,10 @@ async function run_script(
       reject("Timed out after " + timeout_seconds + " seconds")
     }, timeout_seconds * 1000)
 
+    const command = commandExistsSync(executable_name)
+      ? executable_name
+      : path.join(executable_path, executable_name)
+    console.log("run_script", command, args)
     const child = child_process.spawn(command, args, {
       encoding: "utf8",
       shell: true,
@@ -109,7 +122,8 @@ async function run_script(
 }
 
 async function run_back(
-  command,
+  executable_name,
+  executable_path,
   args = {
     project_folder_path,
     upload_folder_path: undefined,
@@ -128,13 +142,22 @@ async function run_back(
       "--allowed_origin http://localhost:*",
       "--timeout " + 0,
     ]
-    console.log("run_back", command, back_args)
-    await run_script(command, back_args, "Serving Flask app")
+    console.log("run_back", executable_name, executable_path, back_args)
+    await run_script(
+      executable_name,
+      executable_path,
+      back_args,
+      "Serving Flask app",
+    )
     resolve(port)
   })
 }
 
-async function run_viewer(command, args = { project_folder_path }) {
+async function run_viewer(
+  executable_name,
+  executable_path,
+  args = { project_folder_path },
+) {
   return new Promise(async (resolve, reject) => {
     const port = await get_available_port()
     const viewer_args = [
@@ -142,8 +165,13 @@ async function run_viewer(command, args = { project_folder_path }) {
       "--data_folder_path " + args.project_folder_path,
       "--timeout " + 0,
     ]
-    console.log("run_viewer", command, viewer_args)
-    await run_script(command, viewer_args, "Starting factory")
+    console.log("run_viewer", executable_name, executable_path, viewer_args)
+    await run_script(
+      executable_name,
+      executable_path,
+      viewer_args,
+      "Starting factory",
+    )
     resolve(port)
   })
 }
@@ -224,19 +252,27 @@ function kill_viewer(viewer_port) {
 async function run_browser(
   script_name,
   microservices_options = {
-    back: { command, args: { project_folder_path } },
-    viewer: { command, args: { project_folder_path } },
+    back: { executable_name, executable_path, args: { project_folder_path } },
+    viewer: { executable_name, executable_path, args: { project_folder_path } },
   },
 ) {
   console.log("microservices_options", microservices_options)
-  const back_promise = run_back(microservices_options.back.command, {
-    ...microservices_options.back.args,
-  })
+  const back_promise = run_back(
+    microservices_options.back.executable_name,
+    microservices_options.back.executable_path,
+    {
+      ...microservices_options.back.args,
+    },
+  )
   console.log("back_promise", back_promise)
 
-  const viewer_promise = run_viewer(microservices_options.viewer.command, {
-    ...microservices_options.viewer.args,
-  })
+  const viewer_promise = run_viewer(
+    microservices_options.viewer.executable_name,
+    microservices_options.viewer.executable_path,
+    {
+      ...microservices_options.viewer.args,
+    },
+  )
   console.log("viewer_promise", viewer_promise)
 
   const [back_port, viewer_port] = await Promise.all([

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 }