@geode/opengeodeweb-front 10.3.0 → 10.3.1

package/tests/unit/components/ObjectSelector.nuxt.test.js

@@ -1,34 +1,34 @@
-import { describe, expect, test, vi } from "vitest"
-import { registerEndpoint, mountSuspended } from "@nuxt/test-utils/runtime"
-import { flushPromises } from "@vue/test-utils"
 import * as components from "vuetify/components"
-import { setActivePinia } from "pinia"
-import { createTestingPinia } from "@pinia/testing"
+import { describe, expect, test } from "vitest"
+import { mountSuspended, registerEndpoint } from "@nuxt/test-utils/runtime"
+import { flushPromises } from "@vue/test-utils"
 
-import schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+import { setupActivePinia, vuetify } from "../../utils"
 import ObjectSelector from "@ogw_front/components/ObjectSelector"
+import schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
 import { useGeodeStore } from "@ogw_front/stores/geode"
-import { vuetify } from "../../utils"
 
-const allowed_objects = schemas.opengeodeweb_back.allowed_objects
+const EXPECTED_LENGTH = 1
+const FIRST_INDEX = 0
+const LOADABLE_SCORE = 1
+const PRIORITY_1 = 1
+const PRIORITY_2 = 2
 
-describe("ObjectSelector", async () => {
-  const pinia = createTestingPinia({
-    stubActions: false,
-    createSpy: vi.fn,
-  })
-  setActivePinia(pinia)
+const { allowed_objects } = schemas.opengeodeweb_back
+
+describe(ObjectSelector, () => {
+  const pinia = setupActivePinia()
   const geodeStore = useGeodeStore()
   geodeStore.base_url = ""
 
   test(`test loadable with one class`, async () => {
-    var response = {
+    const response = {
       allowed_objects: {},
     }
     const geode_object_1 = "BRep"
     response["allowed_objects"][geode_object_1] = { is_loadable: true }
     registerEndpoint(allowed_objects.$id, {
-      method: allowed_objects.methods[0],
+      method: allowed_objects.methods[FIRST_INDEX],
       handler: () => response,
     })
     const wrapper = await mountSuspended(ObjectSelector, {
@@ -41,15 +41,15 @@ describe("ObjectSelector", async () => {
     const v_img = v_card.findComponent(components.VImg)
     expect(v_img.vm.src).toContain(`${geode_object_1}.svg`)
     expect(wrapper.emitted()).toHaveProperty("update_values")
-    expect(wrapper.emitted().update_values).toHaveLength(1)
-    expect(wrapper.emitted().update_values[0][0]).toEqual({
+    expect(wrapper.emitted().update_values).toHaveLength(EXPECTED_LENGTH)
+    expect(wrapper.emitted().update_values[FIRST_INDEX][FIRST_INDEX]).toEqual({
       geode_object_type: geode_object_1,
     })
     wrapper.unmount()
   })
 
   test(`test loabable with multiple classes`, async () => {
-    var response = {
+    const response = {
       allowed_objects: {},
     }
     const geode_object_1 = "BRep"
@@ -57,7 +57,7 @@ describe("ObjectSelector", async () => {
     response["allowed_objects"][geode_object_1] = { is_loadable: true }
     response["allowed_objects"][geode_object_2] = { is_loadable: true }
     registerEndpoint(allowed_objects.$id, {
-      method: allowed_objects.methods[0],
+      method: allowed_objects.methods[FIRST_INDEX],
       handler: () => response,
     })
     const wrapper = await mountSuspended(ObjectSelector, {
@@ -73,31 +73,27 @@ describe("ObjectSelector", async () => {
     await v_card.trigger("click")
     await flushPromises()
     expect(wrapper.emitted()).toHaveProperty("update_values")
-    console.log(
-      "wrapper.emitted().update_values",
-      wrapper.emitted().update_values,
-    )
-    expect(wrapper.emitted().update_values).toHaveLength(1)
-    expect(wrapper.emitted().update_values[0][0]).toEqual({
+    expect(wrapper.emitted().update_values).toHaveLength(EXPECTED_LENGTH)
+    expect(wrapper.emitted().update_values[FIRST_INDEX][FIRST_INDEX]).toEqual({
       geode_object_type: geode_object_1,
     })
     wrapper.unmount()
   })
 
   test(`test object_priority when is_loadable scores equal`, async () => {
-    var response = { allowed_objects: {} }
+    const response = { allowed_objects: {} }
     const geode_object_1 = "BRep"
     const geode_object_2 = "EdgedCurve3D"
     response["allowed_objects"][geode_object_1] = {
-      is_loadable: 1.0,
-      object_priority: 2,
+      is_loadable: LOADABLE_SCORE,
+      object_priority: PRIORITY_2,
     }
     response["allowed_objects"][geode_object_2] = {
-      is_loadable: 1.0,
-      object_priority: 1,
+      is_loadable: LOADABLE_SCORE,
+      object_priority: PRIORITY_1,
     }
     registerEndpoint(allowed_objects.$id, {
-      method: allowed_objects.methods[0],
+      method: allowed_objects.methods[FIRST_INDEX],
       handler: () => response,
     })
     const wrapper = await mountSuspended(ObjectSelector, {
@@ -109,8 +105,8 @@ describe("ObjectSelector", async () => {
 
     await flushPromises()
     expect(wrapper.emitted()).toHaveProperty("update_values")
-    expect(wrapper.emitted().update_values).toHaveLength(1)
-    expect(wrapper.emitted().update_values[0][0]).toEqual({
+    expect(wrapper.emitted().update_values).toHaveLength(EXPECTED_LENGTH)
+    expect(wrapper.emitted().update_values[FIRST_INDEX][FIRST_INDEX]).toEqual({
       geode_object_type: geode_object_1,
     })
     wrapper.unmount()

package/tests/unit/components/PackagesVersions.nuxt.test.js

@@ -1,18 +1,15 @@
-import { describe, expect, test, vi } from "vitest"
+import { describe, expect, test } from "vitest"
 import { mountSuspended, registerEndpoint } from "@nuxt/test-utils/runtime"
-import { setActivePinia } from "pinia"
-import { createTestingPinia } from "@pinia/testing"
 
+import { setupActivePinia, vuetify } from "../../utils"
 import PackagesVersions from "@ogw_front/components/PackagesVersions"
 import { useGeodeStore } from "@ogw_front/stores/geode"
-import { vuetify } from "../../utils"
 
-describe("PackagesVersions", async () => {
+const FIRST_INDEX = 0
+
+describe(PackagesVersions, async () => {
   test(`Mount`, async () => {
-    const pinia = createTestingPinia({
-      createSpy: vi.fn,
-    })
-    setActivePinia(pinia)
+    const pinia = setupActivePinia()
     const geodeStore = useGeodeStore()
     geodeStore.base_url = ""
 
@@ -24,7 +21,7 @@ describe("PackagesVersions", async () => {
       additionalProperties: false,
     }
     registerEndpoint(schema.$id, {
-      method: schema.methods[0],
+      method: schema.methods[FIRST_INDEX],
       handler: () => ({
         versions: [
           {
@@ -40,6 +37,6 @@ describe("PackagesVersions", async () => {
       },
       props: { schema },
     })
-    expect(wrapper.exists()).toBe(true)
+    expect(wrapper.exists()).toBeTruthy()
   })
 })

package/tests/unit/components/Step.nuxt.test.js

@@ -1,13 +1,16 @@
+import { computed, reactive, ref, shallowRef } from "vue"
 import { describe, expect, test } from "vitest"
+import ResizeObserver from "resize-observer-polyfill"
 import { mount } from "@vue/test-utils"
-import Step from "@ogw_front/components/Step"
+
 import ObjectSelector from "@ogw_front/components/ObjectSelector"
+import Step from "@ogw_front/components/Step"
 
 import { vuetify } from "../../utils"
 
-global.ResizeObserver = require("resize-observer-polyfill")
+globalThis.ResizeObserver = ResizeObserver
 
-describe("Step", async () => {
+describe(Step, () => {
   test(`BRep`, async () => {
     const geode_object_type = ref("BRep")
     const files = ref([])
@@ -20,9 +23,7 @@ describe("Step", async () => {
           component: {
             component_name: shallowRef(ObjectSelector),
             component_options: {
-              filenames: computed(() => {
-                return files.value.map((file) => file.name)
-              }),
+              filenames: computed(() => files.value.map((file) => file.name)),
               key: "",
             },
           },
@@ -43,6 +44,6 @@ describe("Step", async () => {
       },
       props: { step_index: 0 },
     })
-    expect(wrapper.exists()).toBe(true)
+    expect(wrapper.exists()).toBeTruthy()
   })
 })

package/tests/unit/components/Stepper.nuxt.test.js

@@ -1,19 +1,24 @@
+// Third party imports
+import { computed, reactive, ref, shallowRef } from "vue"
 import { describe, expect, test } from "vitest"
-import { mountSuspended } from "@vue/test-utils"
+import ResizeObserver from "resize-observer-polyfill"
+import { mountSuspended } from "@nuxt/test-utils/runtime"
 
-import Stepper from "@ogw_front/components/Stepper"
+// Local imports
 import ObjectSelector from "@ogw_front/components/ObjectSelector"
-import { mountSuspended } from "@nuxt/test-utils/runtime"
+import Stepper from "@ogw_front/components/Stepper"
 import { vuetify } from "../../utils"
 
-global.ResizeObserver = require("resize-observer-polyfill")
+const FIRST_INDEX = 0
+
+globalThis.ResizeObserver = ResizeObserver
 
-describe("Stepper", async () => {
+describe(Stepper, () => {
   test(`Mount`, async () => {
     const geode_object_type = ref("BRep")
     const files = ref([])
     const stepper_tree = reactive({
-      current_step_index: ref(0),
+      current_step_index: ref(FIRST_INDEX),
       geode_object_type,
       steps: [
         {
@@ -21,18 +26,15 @@ describe("Stepper", async () => {
           component: {
             component_name: shallowRef(ObjectSelector),
             component_options: {
-              filenames: computed(() => {
-                return files.value.map((file) => file.name)
-              }),
+              filenames: computed(() => files.value.map((file) => file.name)),
               key: "",
             },
           },
           chips: computed(() => {
             if (geode_object_type.value === "") {
               return []
-            } else {
-              return [geode_object_type.value]
             }
+            return [geode_object_type.value]
           }),
         },
       ],
@@ -43,6 +45,6 @@ describe("Stepper", async () => {
         provide: { stepper_tree },
       },
     })
-    expect(wrapper.exists()).toBe(true)
+    expect(wrapper.exists()).toBeTruthy()
   })
 })

package/tests/unit/composables/ProjectManager.nuxt.test.js

@@ -1,10 +1,32 @@
+// Third party imports
 import { beforeEach, describe, expect, test, vi } from "vitest"
-import { setActivePinia } from "pinia"
-import { createTestingPinia } from "@pinia/testing"
 
 // Local imports
-import { useProjectManager } from "@ogw_front/composables/project_manager"
 import { appMode } from "@ogw_front/utils/app_mode"
+import { setupActivePinia } from "../../utils"
+import { useProjectManager } from "@ogw_front/composables/project_manager"
+
+// Constants
+const PANEL_WIDTH = 300
+const Z_SCALE = 1.5
+const FOCAL_POINT1 = 1
+const FOCAL_POINT2 = 2
+const FOCAL_POINT3 = 3
+const FOCAL_POINT = [FOCAL_POINT1, FOCAL_POINT2, FOCAL_POINT3]
+const VIEW_UP1 = 0
+const VIEW_UP2 = 1
+const VIEW_UP3 = 0
+const VIEW_UP = [VIEW_UP1, VIEW_UP2, VIEW_UP3]
+const POSITION1 = 10
+const POSITION2 = 11
+const POSITION3 = 12
+const POSITION = [POSITION1, POSITION2, POSITION3]
+const VIEW_ANGLE = 30
+const CLIPPING_RANGE1 = 0.1
+const CLIPPING_RANGE2 = 1000
+const CLIPPING_RANGE = [CLIPPING_RANGE1, CLIPPING_RANGE2]
+const POINT_SIZE = 2
+const VIEWER_CALL_COUNT = 2
 
 // Snapshot
 const snapshotMock = {
@@ -23,10 +45,10 @@ const snapshotMock = {
   },
   treeview: {
     isAdditionnalTreeDisplayed: false,
-    panelWidth: 320,
+    panelWidth: PANEL_WIDTH,
     model_id: "",
     isTreeCollection: false,
-    selectedTree: null,
+    selectedTree: undefined,
     selectionIds: [],
   },
   dataStyle: {
@@ -37,21 +59,21 @@ const snapshotMock = {
           coloring: {
             active: "color",
             color: { r: 255, g: 255, b: 255 },
-            vertex: null,
+            vertex: undefined,
           },
-          size: 2,
+          size: POINT_SIZE,
         },
       },
     },
   },
   hybridViewer: {
-    zScale: 1.5,
+    zScale: Z_SCALE,
     camera_options: {
-      focal_point: [1, 2, 3],
-      view_up: [0, 1, 0],
-      position: [10, 11, 12],
-      view_angle: 30,
-      clipping_range: [0.1, 1000],
+      focal_point: FOCAL_POINT,
+      view_up: VIEW_UP,
+      position: POSITION,
+      view_angle: VIEW_ANGLE,
+      clipping_range: CLIPPING_RANGE,
     },
   },
 }
@@ -67,56 +89,54 @@ const infraStoreMock = {
   ID: "1234",
 }
 const viewerStoreMock = {
-  ws_connect: vi.fn(() => Promise.resolve()),
+  ws_connect: vi.fn().mockResolvedValue(),
   base_url: vi.fn(() => ""),
-  request: vi.fn(() => Promise.resolve()),
+  request: vi.fn().mockResolvedValue(),
 }
 const treeviewStoreMock = {
   clear: vi.fn(),
-  importStores: vi.fn(() => Promise.resolve()),
+  importStores: vi.fn().mockResolvedValue(),
   finalizeImportSelection: vi.fn(),
-  addItem: vi.fn(() => Promise.resolve()),
+  addItem: vi.fn().mockResolvedValue(),
 }
 const dataStoreMock = {
   clear: vi.fn(),
-  registerObject: vi.fn(() => Promise.resolve()),
-  addItem: vi.fn(() => Promise.resolve()),
+  registerObject: vi.fn().mockResolvedValue(),
+  addItem: vi.fn().mockResolvedValue(),
 }
 const dataStyleStoreMock = {
-  importStores: vi.fn(() => Promise.resolve()),
-  applyAllStylesFromState: vi.fn(() => Promise.resolve()),
-  addDataStyle: vi.fn(() => Promise.resolve()),
-  applyDefaultStyle: vi.fn(() => Promise.resolve()),
+  importStores: vi.fn().mockResolvedValue(),
+  applyAllStylesFromState: vi.fn().mockResolvedValue(),
+  addDataStyle: vi.fn().mockResolvedValue(),
+  applyDefaultStyle: vi.fn().mockResolvedValue(),
 }
+
+const viewer_call_mock_fn = vi.fn().mockResolvedValue()
+
 const hybridViewerStoreMock = {
   clear: vi.fn(),
-  initHybridViewer: vi.fn(() => Promise.resolve()),
-  importStores: vi.fn(async (snapshot) => {
-    if (snapshot?.zScale != null) {
+  initHybridViewer: vi.fn().mockResolvedValue(),
+  importStores: vi.fn((snapshot) => {
+    if (snapshot?.zScale !== undefined) {
       hybridViewerStoreMock.setZScaling(snapshot.zScale)
     }
     if (snapshot?.camera_options) {
-      const { viewer_call } =
-        await import("../../../internal/utils/viewer_call")
-      viewer_call({
+      viewer_call_mock_fn({
         schema: { $id: "opengeodeweb_viewer.viewer.update_camera" },
         params: { camera_options: snapshot.camera_options },
       })
       hybridViewerStoreMock.remoteRender()
     }
   }),
-  addItem: vi.fn(() => Promise.resolve()),
+  addItem: vi.fn().mockResolvedValue(),
   remoteRender: vi.fn(),
   setZScaling: vi.fn(),
 }
 
-// Mocks
-vi.stubGlobal(
-  "$fetch",
-  vi.fn(async () => ({ snapshot: snapshotMock })),
-)
+// MOCKS
+vi.stubGlobal("$fetch", vi.fn().mockResolvedValue({ snapshot: snapshotMock }))
 vi.mock("../../../internal/utils/viewer_call", () => ({
-  viewer_call: vi.fn(() => Promise.resolve()),
+  viewer_call: viewer_call_mock_fn,
 }))
 
 vi.mock("@ogw_front/composables/api_fetch", () => ({
@@ -124,10 +144,12 @@ vi.mock("@ogw_front/composables/api_fetch", () => ({
     const response = {
       _data: new Blob(["zipcontent"], { type: "application/zip" }),
       headers: {
-        get: (k) => (k === "new-file-name" ? "project_123.vease" : null),
+        get: (k) => (k === "new-file-name" ? "project_123.vease" : undefined),
       },
     }
-    if (options.response_function) await options.response_function(response)
+    if (options.response_function) {
+      await options.response_function(response)
+    }
     return response
   }),
 }))
@@ -163,9 +185,9 @@ vi.stubGlobal("useAppStore", () => ({
   exportStores: vi.fn(() => ({ projectName: "mockedProject" })),
 }))
 
-const mockLockRequest = vi.fn().mockImplementation(async (name, callback) => {
-  return callback({ name })
-})
+const mockLockRequest = vi
+  .fn()
+  .mockImplementation(async (name, task) => await task({ name }))
 
 vi.stubGlobal("navigator", {
   ...navigator,
@@ -174,37 +196,85 @@ vi.stubGlobal("navigator", {
   },
 })
 
-describe("ProjectManager composable (compact)", () => {
-  beforeEach(async () => {
-    const pinia = createTestingPinia({ stubActions: false, createSpy: vi.fn })
-    setActivePinia(pinia)
+function verifyViewerCalls() {
+  expect(viewerStoreMock.ws_connect).toHaveBeenCalledWith()
+  expect(viewer_call_mock_fn).toHaveBeenCalledTimes(VIEWER_CALL_COUNT)
+}
 
-    // reset spies
-    for (const store of [
-      viewerStoreMock,
-      treeviewStoreMock,
-      dataStoreMock,
-      dataStyleStoreMock,
-      hybridViewerStoreMock,
-    ]) {
-      Object.values(store).forEach(
-        (v) => typeof v === "function" && v.mockClear && v.mockClear(),
-      )
+function verifyStoreImports() {
+  expect(treeviewStoreMock.importStores).toHaveBeenCalledWith(
+    snapshotMock.treeview,
+  )
+  expect(hybridViewerStoreMock.initHybridViewer).toHaveBeenCalledWith()
+  expect(hybridViewerStoreMock.importStores).toHaveBeenCalledWith(
+    snapshotMock.hybridViewer,
+  )
+  expect(hybridViewerStoreMock.setZScaling).toHaveBeenCalledWith(Z_SCALE)
+}
+
+function verifyDataManagement() {
+  expect(dataStyleStoreMock.importStores).toHaveBeenCalledWith(
+    snapshotMock.dataStyle,
+  )
+  expect(dataStyleStoreMock.applyAllStylesFromState).toHaveBeenCalledWith()
+  expect(dataStoreMock.registerObject).toHaveBeenCalledWith("abc123")
+  expect(dataStoreMock.addItem).toHaveBeenCalledWith(
+    "abc123",
+    expect.anything(),
+  )
+  expect(treeviewStoreMock.addItem).toHaveBeenCalledWith(
+    "PointSet2D",
+    "My Data",
+    "abc123",
+    "mesh",
+  )
+}
+
+function verifyRemaining() {
+  expect(hybridViewerStoreMock.addItem).toHaveBeenCalledWith("abc123")
+  expect(dataStyleStoreMock.addDataStyle).toHaveBeenCalledWith(
+    "abc123",
+    "PointSet2D",
+  )
+  expect(dataStyleStoreMock.applyDefaultStyle).toHaveBeenCalledWith("abc123")
+  expect(hybridViewerStoreMock.remoteRender).toHaveBeenCalledWith()
+}
+
+beforeEach(() => {
+  setupActivePinia()
+  // reset spies
+  const storesList = [
+    viewerStoreMock,
+    treeviewStoreMock,
+    dataStoreMock,
+    dataStyleStoreMock,
+    hybridViewerStoreMock,
+  ]
+  for (const store of storesList) {
+    const values = Object.values(store)
+    for (const value of values) {
+      if (typeof value === "function" && value.mockClear) {
+        value.mockClear()
+      }
     }
-    const { viewer_call } = await import("../../../internal/utils/viewer_call")
-    viewer_call.mockClear()
-  })
+  }
+  viewer_call_mock_fn.mockClear()
+})
 
+describe("projectManager composable (compact)", () => {
   test("exportProject", async () => {
     const { exportProject } = useProjectManager()
     const { default: fileDownload } = await import("js-file-download")
 
     await exportProject()
 
-    expect(fileDownload).toHaveBeenCalled()
+    expect(fileDownload).toHaveBeenCalledWith(
+      { snapshot: snapshotMock },
+      "project.vease",
+    )
   })
 
-  test("importProjectFile with snapshot", async () => {
+  test("importProjectFile with snapshot - Viewer and Stores", async () => {
     const { importProjectFile } = useProjectManager()
     const file = new Blob(['{"dataBase":{"db":{}}}'], {
       type: "application/json",
@@ -212,47 +282,19 @@ describe("ProjectManager composable (compact)", () => {
 
     await importProjectFile(file)
 
-    const { viewer_call } = await import("../../../internal/utils/viewer_call")
-
-    expect(viewerStoreMock.ws_connect).toHaveBeenCalled()
-    expect(viewer_call).toHaveBeenCalledTimes(2)
-
-    expect(treeviewStoreMock.importStores).toHaveBeenCalledWith(
-      snapshotMock.treeview,
-    )
-    expect(hybridViewerStoreMock.initHybridViewer).toHaveBeenCalled()
-    expect(hybridViewerStoreMock.importStores).toHaveBeenCalledWith(
-      snapshotMock.hybridViewer,
-    )
-    expect(hybridViewerStoreMock.setZScaling).toHaveBeenCalledWith(1.5)
+    verifyViewerCalls()
+    verifyStoreImports()
+  })
 
-    expect(dataStyleStoreMock.importStores).toHaveBeenCalledWith(
-      snapshotMock.dataStyle,
-    )
-    expect(dataStyleStoreMock.applyAllStylesFromState).toHaveBeenCalled()
+  test("importProjectFile with snapshot - Data and Rendering", async () => {
+    const { importProjectFile } = useProjectManager()
+    const file = new Blob(['{"dataBase":{"db":{}}}'], {
+      type: "application/json",
+    })
 
-    expect(dataStoreMock.registerObject).toHaveBeenCalledWith("abc123")
-    expect(dataStoreMock.addItem).toHaveBeenCalledWith(
-      "abc123",
-      expect.objectContaining({
-        viewer_type: "mesh",
-        geode_object_type: "PointSet2D",
-        name: "My Data",
-      }),
-    )
-    expect(treeviewStoreMock.addItem).toHaveBeenCalledWith(
-      "PointSet2D",
-      "My Data",
-      "abc123",
-      "mesh",
-    )
-    expect(hybridViewerStoreMock.addItem).toHaveBeenCalledWith("abc123")
-    expect(dataStyleStoreMock.addDataStyle).toHaveBeenCalledWith(
-      "abc123",
-      "PointSet2D",
-    )
-    expect(dataStyleStoreMock.applyDefaultStyle).toHaveBeenCalledWith("abc123")
+    await importProjectFile(file)
 
-    expect(hybridViewerStoreMock.remoteRender).toHaveBeenCalled()
+    verifyDataManagement()
+    verifyRemaining()
   })
 })