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

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

@@ -1,22 +1,22 @@
 // Third party imports
-import { computed, reactive, ref, shallowRef } from "vue"
-import { describe, expect, test } from "vitest"
-import ResizeObserver from "resize-observer-polyfill"
-import { mountSuspended } from "@nuxt/test-utils/runtime"
+import { computed, reactive, ref, shallowRef } from "vue";
+import { describe, expect, test } from "vitest";
+import ResizeObserver from "resize-observer-polyfill";
+import { mountSuspended } from "@nuxt/test-utils/runtime";
 
 // Local imports
-import ObjectSelector from "@ogw_front/components/ObjectSelector"
-import Stepper from "@ogw_front/components/Stepper"
-import { vuetify } from "@ogw_tests/utils"
+import ObjectSelector from "@ogw_front/components/ObjectSelector";
+import Stepper from "@ogw_front/components/Stepper";
+import { vuetify } from "@ogw_tests/utils";
 
-const FIRST_INDEX = 0
+const FIRST_INDEX = 0;
 
-globalThis.ResizeObserver = ResizeObserver
+globalThis.ResizeObserver = ResizeObserver;
 
 describe(Stepper, () => {
   test(`Mount`, async () => {
-    const geode_object_type = ref("BRep")
-    const files = ref([])
+    const geode_object_type = ref("BRep");
+    const files = ref([]);
     const stepper_tree = reactive({
       current_step_index: ref(FIRST_INDEX),
       geode_object_type,
@@ -32,19 +32,19 @@ describe(Stepper, () => {
           },
           chips: computed(() => {
             if (geode_object_type.value === "") {
-              return []
+              return [];
             }
-            return [geode_object_type.value]
+            return [geode_object_type.value];
           }),
         },
       ],
-    })
+    });
     const wrapper = await mountSuspended(Stepper, {
       global: {
         plugins: [vuetify],
         provide: { stepper_tree },
       },
-    })
-    expect(wrapper.exists()).toBeTruthy()
-  })
-})
+    });
+    expect(wrapper.exists()).toBeTruthy();
+  });
+});

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

@@ -1,19 +1,19 @@
 // Third party imports
-import { beforeEach, describe, expect, test } from "vitest"
-import { registerEndpoint } from "@nuxt/test-utils/runtime"
+import { beforeEach, describe, expect, test } from "vitest";
+import { registerEndpoint } from "@nuxt/test-utils/runtime";
 
 // Local imports
-import { setupActivePinia } from "@ogw_tests/utils"
-import { useFeedbackStore } from "@ogw_front/stores/feedback"
-import { useGeodeStore } from "@ogw_front/stores/geode"
+import { setupActivePinia } from "@ogw_tests/utils";
+import { useFeedbackStore } from "@ogw_front/stores/feedback";
+import { useGeodeStore } from "@ogw_front/stores/geode";
 
-const FIRST_INDEX = 0
+const FIRST_INDEX = 0;
 
 describe("geodeStore.request()", () => {
-  setupActivePinia()
-  const geodeStore = useGeodeStore()
-  const feedbackStore = useFeedbackStore()
-  geodeStore.base_url = ""
+  setupActivePinia();
+  const geodeStore = useGeodeStore();
+  const feedbackStore = useFeedbackStore();
+  geodeStore.base_url = "";
 
   const schema = {
     $id: "/test",
@@ -26,15 +26,15 @@ describe("geodeStore.request()", () => {
     },
     required: ["test"],
     additionalProperties: false,
-  }
+  };
 
   beforeEach(async () => {
-    await feedbackStore.$reset()
-    await geodeStore.$reset()
-    geodeStore.base_url = ""
-  })
+    await feedbackStore.$reset();
+    await geodeStore.$reset();
+    geodeStore.base_url = "";
+  });
 
-  test("invalid schema", async () => {
+  test("invalid schema", () => {
     const invalid_schema = {
       $id: "/test",
       type: "object",
@@ -46,33 +46,31 @@ describe("geodeStore.request()", () => {
       },
       required: ["test"],
       additionalProperties: false,
-    }
-    const params = { test: "hello" }
-    expect(() => geodeStore.request(invalid_schema, params)).toThrow(
-      "data/test must be number",
-    )
-  })
+    };
+    const params = { test: "hello" };
+    expect(() => geodeStore.request(invalid_schema, params)).toThrow("data/test must be number");
+  });
 
-  test("invalid params", async () => {
-    const params = {}
+  test("invalid params", () => {
+    const params = {};
     expect(() => geodeStore.request(schema, params)).toThrow(
       "data must have required property 'test'",
-    )
-  })
+    );
+  });
 
   test("request with callbacks", async () => {
-    const params = { test: "hello" }
-    let errorCalled = false
+    const params = { test: "hello" };
+    let errorCalled = false;
     const callbacks = {
-      request_error_function: async () => {
-        errorCalled = true
+      request_error_function: () => {
+        errorCalled = true;
       },
-    }
+    };
     registerEndpoint(schema.$id, {
       method: schema.methods[FIRST_INDEX],
       handler: () => ({ result: "success" }),
-    })
-    await geodeStore.request(schema, params, callbacks)
-    expect(errorCalled).toBeFalsy()
-  })
-})
+    });
+    await geodeStore.request(schema, params, callbacks);
+    expect(errorCalled).toBeFalsy();
+  });
+});

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

@@ -1,32 +1,32 @@
 // Third party imports
-import { beforeEach, describe, expect, test, vi } from "vitest"
+import { beforeEach, describe, expect, test, vi } from "vitest";
 
 // Local imports
-import { appMode } from "@ogw_front/utils/local/app_mode"
-import { setupActivePinia } from "@ogw_tests/utils"
-import { useProjectManager } from "@ogw_front/composables/project_manager"
+import { appMode } from "@ogw_front/utils/local/app_mode";
+import { setupActivePinia } from "@ogw_tests/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
+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 = {
@@ -76,68 +76,68 @@ const snapshotMock = {
       clipping_range: CLIPPING_RANGE,
     },
   },
-}
+};
 
 const geodeStoreMock = {
   start_request: vi.fn(),
   stop_request: vi.fn(),
   base_url: vi.fn(() => ""),
   $reset: vi.fn(),
-}
+};
 const infraStoreMock = {
   app_mode: appMode.BROWSER,
   ID: "1234",
-}
+};
 const viewerStoreMock = {
   ws_connect: vi.fn().mockResolvedValue(),
   base_url: vi.fn(() => ""),
   request: vi.fn().mockResolvedValue(),
-}
+};
 const treeviewStoreMock = {
   clear: vi.fn(),
   importStores: vi.fn().mockResolvedValue(),
   finalizeImportSelection: vi.fn(),
   addItem: vi.fn().mockResolvedValue(),
-}
+};
 const dataStoreMock = {
   clear: vi.fn(),
   registerObject: vi.fn().mockResolvedValue(),
   addItem: vi.fn().mockResolvedValue(),
-}
+};
 const dataStyleStoreMock = {
   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 viewer_call_mock_fn = vi.fn().mockResolvedValue();
 
 const hybridViewerStoreMock = {
   clear: vi.fn(),
   initHybridViewer: vi.fn().mockResolvedValue(),
   importStores: vi.fn((snapshot) => {
     if (snapshot?.zScale !== undefined) {
-      hybridViewerStoreMock.setZScaling(snapshot.zScale)
+      hybridViewerStoreMock.setZScaling(snapshot.zScale);
     }
     if (snapshot?.camera_options) {
       viewer_call_mock_fn({
         schema: { $id: "opengeodeweb_viewer.viewer.update_camera" },
         params: { camera_options: snapshot.camera_options },
-      })
-      hybridViewerStoreMock.remoteRender()
+      });
+      hybridViewerStoreMock.remoteRender();
     }
   }),
   addItem: vi.fn().mockResolvedValue(),
   remoteRender: vi.fn(),
   setZScaling: vi.fn(),
-}
+};
 
 // MOCKS
-vi.stubGlobal("$fetch", vi.fn().mockResolvedValue({ snapshot: snapshotMock }))
+vi.stubGlobal("$fetch", vi.fn().mockResolvedValue({ snapshot: snapshotMock }));
 vi.mock(import("@ogw_internal/utils/viewer_call"), () => ({
   viewer_call: viewer_call_mock_fn,
-}))
+}));
 
 vi.mock(import("@ogw_front/composables/api_fetch"), () => ({
   api_fetch: vi.fn(async (_req, options = {}) => {
@@ -146,151 +146,132 @@ vi.mock(import("@ogw_front/composables/api_fetch"), () => ({
       headers: {
         get: (k) => (k === "new-file-name" ? "project_123.vease" : undefined),
       },
-    }
+    };
     if (options.response_function) {
-      await options.response_function(response)
+      await options.response_function(response);
     }
-    return response
+    return response;
   }),
-}))
-vi.mock(import("js-file-download"), () => ({ default: vi.fn() }))
+}));
+vi.mock(import("js-file-download"), () => ({ default: vi.fn() }));
 vi.mock(import("@ogw_front/stores/infra"), () => ({
   useInfraStore: () => infraStoreMock,
-}))
+}));
 vi.mock(import("@ogw_front/stores/viewer"), () => ({
   useViewerStore: () => viewerStoreMock,
-}))
+}));
 vi.mock(import("@ogw_front/stores/treeview"), () => ({
   useTreeviewStore: () => treeviewStoreMock,
-}))
+}));
 vi.mock(import("@ogw_front/stores/data"), () => ({
   useDataStore: () => dataStoreMock,
-}))
+}));
 vi.mock(import("@ogw_front/stores/data_style"), () => ({
   useDataStyleStore: () => dataStyleStoreMock,
-}))
+}));
 vi.mock(import("@ogw_front/stores/hybrid_viewer"), () => ({
   useHybridViewerStore: () => hybridViewerStoreMock,
-}))
+}));
 vi.mock(import("@ogw_front/stores/geode"), () => ({
   useGeodeStore: () => geodeStoreMock,
-}))
+}));
 vi.mock(import("@ogw_front/stores/app"), () => ({
   useAppStore: () => ({
     exportStores: vi.fn(() => ({ projectName: "mockedProject" })),
   }),
-}))
+}));
 
 vi.stubGlobal("useAppStore", () => ({
   exportStores: vi.fn(() => ({ projectName: "mockedProject" })),
-}))
+}));
 
-const mockLockRequest = vi
-  .fn()
-  .mockImplementation(async (name, task) => await task({ name }))
+const mockLockRequest = vi.fn().mockImplementation(async (name, task) => await task({ name }));
 
 vi.stubGlobal("navigator", {
   ...navigator,
   locks: {
     request: mockLockRequest,
   },
-})
+});
 
 function verifyViewerCalls() {
-  expect(viewerStoreMock.ws_connect).toHaveBeenCalledWith()
-  expect(viewer_call_mock_fn).toHaveBeenCalledTimes(VIEWER_CALL_COUNT)
+  expect(viewerStoreMock.ws_connect).toHaveBeenCalledWith();
+  expect(viewer_call_mock_fn).toHaveBeenCalledTimes(VIEWER_CALL_COUNT);
 }
 
 function verifyStoreImports() {
-  expect(treeviewStoreMock.importStores).toHaveBeenCalledWith(
-    snapshotMock.treeview,
-  )
-  expect(hybridViewerStoreMock.initHybridViewer).toHaveBeenCalledWith()
-  expect(hybridViewerStoreMock.importStores).toHaveBeenCalledWith(
-    snapshotMock.hybridViewer,
-  )
-  expect(hybridViewerStoreMock.setZScaling).toHaveBeenCalledWith(Z_SCALE)
+  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(snapshotMock.data.items[0])
-  expect(treeviewStoreMock.addItem).toHaveBeenCalledWith(
-    "PointSet2D",
-    "My Data",
-    "abc123",
-    "mesh",
-  )
+  expect(dataStyleStoreMock.importStores).toHaveBeenCalledWith(snapshotMock.dataStyle);
+  expect(dataStyleStoreMock.applyAllStylesFromState).toHaveBeenCalledWith();
+  expect(dataStoreMock.registerObject).toHaveBeenCalledWith("abc123");
+  expect(dataStoreMock.addItem).toHaveBeenCalledWith(snapshotMock.data.items[0]);
+  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()
+  expect(hybridViewerStoreMock.addItem).toHaveBeenCalledWith("abc123");
+  expect(dataStyleStoreMock.addDataStyle).toHaveBeenCalledWith("abc123", "PointSet2D");
+  expect(dataStyleStoreMock.applyDefaultStyle).toHaveBeenCalledWith("abc123");
+  expect(hybridViewerStoreMock.remoteRender).toHaveBeenCalledWith();
 }
 
 beforeEach(() => {
-  setupActivePinia()
+  setupActivePinia();
   const storesList = [
     viewerStoreMock,
     treeviewStoreMock,
     dataStoreMock,
     dataStyleStoreMock,
     hybridViewerStoreMock,
-  ]
+  ];
   for (const store of storesList) {
-    const values = Object.values(store)
+    const values = Object.values(store);
     for (const value of values) {
       if (typeof value === "function" && value.mockClear) {
-        value.mockClear()
+        value.mockClear();
       }
     }
   }
-  viewer_call_mock_fn.mockClear()
-})
+  viewer_call_mock_fn.mockClear();
+});
 
 describe("projectManager composable (compact)", () => {
   test("exportProject", async () => {
-    const { exportProject } = useProjectManager()
-    const { default: fileDownload } = await import("js-file-download")
+    const { exportProject } = useProjectManager();
+    const { default: fileDownload } = await import("js-file-download");
 
-    await exportProject()
+    await exportProject();
 
-    expect(fileDownload).toHaveBeenCalledWith(
-      { snapshot: snapshotMock },
-      "project.vease",
-    )
-  })
+    expect(fileDownload).toHaveBeenCalledWith({ snapshot: snapshotMock }, "project.vease");
+  });
 
   test("importProjectFile with snapshot - Viewer and Stores", async () => {
-    const { importProjectFile } = useProjectManager()
+    const { importProjectFile } = useProjectManager();
     const file = new Blob(['{"dataBase":{"db":{}}}'], {
       type: "application/json",
-    })
+    });
 
-    await importProjectFile(file)
+    await importProjectFile(file);
 
-    verifyViewerCalls()
-    verifyStoreImports()
-  })
+    verifyViewerCalls();
+    verifyStoreImports();
+  });
 
   test("importProjectFile with snapshot - Data and Rendering", async () => {
-    const { importProjectFile } = useProjectManager()
+    const { importProjectFile } = useProjectManager();
     const file = new Blob(['{"dataBase":{"db":{}}}'], {
       type: "application/json",
-    })
+    });
 
-    await importProjectFile(file)
+    await importProjectFile(file);
 
-    verifyDataManagement()
-    verifyRemaining()
-  })
-})
+    verifyDataManagement();
+    verifyRemaining();
+  });
+});

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

@@ -1,57 +1,57 @@
 // Third party imports
-import { beforeEach, describe, expect, test, vi } from "vitest"
-import { flushPromises } from "@vue/test-utils"
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { flushPromises } from "@vue/test-utils";
 
 // Local imports
-import { Status } from "@ogw_front/utils/status"
-import { run_function_when_microservices_connected } from "@ogw_front/composables/run_function_when_microservices_connected"
-import { setupActivePinia } from "@ogw_tests/utils"
-import { useGeodeStore } from "@ogw_front/stores/geode"
-import { useInfraStore } from "@ogw_front/stores/infra"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { Status } from "@ogw_front/utils/status";
+import { run_function_when_microservices_connected } from "@ogw_front/composables/run_function_when_microservices_connected";
+import { setupActivePinia } from "@ogw_tests/utils";
+import { useGeodeStore } from "@ogw_front/stores/geode";
+import { useInfraStore } from "@ogw_front/stores/infra";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
-const dumb_obj = { dumb_method: () => true }
-let infraStore = undefined
-let geodeStore = undefined
-let viewerStore = undefined
+const dumb_obj = { dumb_method: () => true };
+let infraStore = undefined;
+let geodeStore = undefined;
+let viewerStore = undefined;
 
 beforeEach(() => {
-  setupActivePinia()
-  infraStore = useInfraStore()
-  geodeStore = useGeodeStore()
-  viewerStore = useViewerStore()
+  setupActivePinia();
+  infraStore = useInfraStore();
+  geodeStore = useGeodeStore();
+  viewerStore = useViewerStore();
 
   // Register microservices in infra store
   infraStore.register_microservice(geodeStore, {
     request: vi.fn(),
     connect: vi.fn(),
     launch: vi.fn(),
-  })
+  });
   infraStore.register_microservice(viewerStore, {
     request: vi.fn(),
     connect: vi.fn(),
     launch: vi.fn(),
-  })
+  });
 
-  geodeStore.$patch({ status: Status.NOT_CONNECTED })
-  viewerStore.$patch({ status: Status.NOT_CONNECTED })
-})
+  geodeStore.$patch({ status: Status.NOT_CONNECTED });
+  viewerStore.$patch({ status: Status.NOT_CONNECTED });
+});
 
 describe("when_microservices_connected_run_function", () => {
-  test("microservices not connected", async () => {
-    const spy = vi.spyOn(dumb_obj, "dumb_method")
-    run_function_when_microservices_connected(dumb_obj.dumb_method)
-    geodeStore.$patch({ status: Status.NOT_CONNECTED })
-    viewerStore.$patch({ status: Status.NOT_CONNECTED })
-    expect(spy).not.toHaveBeenCalled()
-  })
+  test("microservices not connected", () => {
+    const spy = vi.spyOn(dumb_obj, "dumb_method");
+    run_function_when_microservices_connected(dumb_obj.dumb_method);
+    geodeStore.$patch({ status: Status.NOT_CONNECTED });
+    viewerStore.$patch({ status: Status.NOT_CONNECTED });
+    expect(spy).not.toHaveBeenCalled();
+  });
 
   test("microservices connected", async () => {
-    const spy = vi.spyOn(dumb_obj, "dumb_method")
-    run_function_when_microservices_connected(dumb_obj.dumb_method)
-    geodeStore.$patch({ status: Status.CONNECTED })
-    viewerStore.$patch({ status: Status.CONNECTED })
-    await flushPromises()
-    expect(spy).toHaveBeenCalledWith()
-  })
-})
+    const spy = vi.spyOn(dumb_obj, "dumb_method");
+    run_function_when_microservices_connected(dumb_obj.dumb_method);
+    geodeStore.$patch({ status: Status.CONNECTED });
+    viewerStore.$patch({ status: Status.CONNECTED });
+    await flushPromises();
+    expect(spy).toHaveBeenCalledWith();
+  });
+});