@geode/opengeodeweb-front 10.3.0 → 10.3.1

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

@@ -1,17 +1,16 @@
-import { describe, expect, test, beforeEach, vi } from "vitest"
-import { setActivePinia } from "pinia"
-import { createTestingPinia } from "@pinia/testing"
+// Third party imports
+import { beforeEach, describe, expect, test } from "vitest"
 import { registerEndpoint } from "@nuxt/test-utils/runtime"
 
-import { useGeodeStore } from "@ogw_front/stores/geode"
+// Local imports
+import { setupActivePinia } from "../../utils"
 import { useFeedbackStore } from "@ogw_front/stores/feedback"
+import { useGeodeStore } from "@ogw_front/stores/geode"
+
+const FIRST_INDEX = 0
 
 describe("geodeStore.request()", () => {
-  const pinia = createTestingPinia({
-    stubActions: false,
-    createSpy: vi.fn,
-  })
-  setActivePinia(pinia)
+  setupActivePinia()
   const geodeStore = useGeodeStore()
   const feedbackStore = useFeedbackStore()
   geodeStore.base_url = ""
@@ -35,12 +34,6 @@ describe("geodeStore.request()", () => {
     geodeStore.base_url = ""
   })
 
-  // test("valid schema and params", async () => {
-  //   const params = { test: "hello" }
-  //   const response = await api_fetch({ schema, params })
-  //   expect(response).toBeDefined()
-  // })
-
   test("invalid schema", async () => {
     const schema = {
       $id: "/test",
@@ -55,14 +48,14 @@ describe("geodeStore.request()", () => {
       additionalProperties: false,
     }
     const params = { test: "hello" }
-    expect(() => geodeStore.request(schema, params)).toThrowError(
+    expect(() => geodeStore.request(schema, params)).toThrow(
       "data/test must be number",
     )
   })
 
   test("invalid params", async () => {
     const params = {}
-    expect(() => geodeStore.request(schema, params)).toThrowError(
+    expect(() => geodeStore.request(schema, params)).toThrow(
       "data must have required property 'test'",
     )
   })
@@ -76,30 +69,10 @@ describe("geodeStore.request()", () => {
       },
     }
     registerEndpoint(schema.$id, {
-      method: schema.methods[0],
+      method: schema.methods[FIRST_INDEX],
       handler: () => ({ result: "success" }),
     })
     await geodeStore.request(schema, params, callbacks)
-    expect(errorCalled).toBe(false)
+    expect(errorCalled).toBeFalsy()
   })
-
-  // test("response handling", async () => {
-  //   const schema = {
-  //     $id: "/test",
-  //     type: "object",
-  //     methods: ["POST"],
-  //     properties: {
-  //       test: {
-  //         type: "string",
-  //       },
-  //     },
-  //     required: ["test"],
-  //     additionalProperties: false,
-  //   }
-  //   const params = { test: "hello" }
-  //   // const responseFunction = jest.fn()
-  //   const response = await api_fetch({ schema, params }, { response_function })
-  //   expect(responseFunction).toHaveBeenCalledTimes(1)
-  //   expect(response).toBeDefined()
-  // })
 })

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

@@ -1,82 +1,57 @@
+// Third party imports
+import { flushPromises } from "@vue/test-utils"
 import { beforeEach, describe, expect, test, vi } from "vitest"
-import Status from "@ogw_front/utils/status"
-
-import { setActivePinia } from "pinia"
-import { createTestingPinia } from "@pinia/testing"
 
+// Local imports
 import { run_function_when_microservices_connected } from "@ogw_front/composables/run_function_when_microservices_connected"
-import { useInfraStore } from "@ogw_front/stores/infra"
+import { setupActivePinia } from "../../utils"
+import Status from "@ogw_front/utils/status"
 import { useGeodeStore } from "@ogw_front/stores/geode"
+import { useInfraStore } from "@ogw_front/stores/infra"
 import { useViewerStore } from "@ogw_front/stores/viewer"
 
-beforeEach(async () => {
-  const pinia = createTestingPinia({
-    stubActions: false,
-    createSpy: vi.fn,
+const dumb_obj = { dumb_method: () => true }
+let infraStore
+let geodeStore
+let viewerStore
+
+beforeEach(() => {
+  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(),
   })
-  setActivePinia(pinia)
-})
-
-describe("run_function_when_microservices_connected", () => {
-  const dumb_obj = { dumb_method: () => true }
-
-  beforeEach(async () => {
-    const infraStore = useInfraStore()
-    const geodeStore = useGeodeStore()
-    const 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(),
-    })
-
-    await geodeStore.$patch({ status: Status.NOT_CONNECTED })
-    await viewerStore.$patch({ status: Status.NOT_CONNECTED })
+  infraStore.register_microservice(viewerStore, {
+    request: vi.fn(),
+    connect: vi.fn(),
+    launch: vi.fn(),
   })
 
-  test("microservices not connected", async () => {
-    const geodeStore = useGeodeStore()
-    const viewerStore = useViewerStore()
-    const infraStore = useInfraStore()
-    const spy = vi.spyOn(dumb_obj, "dumb_method")
-    run_function_when_microservices_connected(dumb_obj.dumb_method)
-    await geodeStore.$patch({ status: Status.NOT_CONNECTED })
-    await viewerStore.$patch({ status: Status.NOT_CONNECTED })
-    console.log("geodeStore", geodeStore.status)
-    console.log("viewerStore", viewerStore.status)
+  geodeStore.$patch({ status: Status.NOT_CONNECTED })
+  viewerStore.$patch({ status: Status.NOT_CONNECTED })
+})
 
-    console.log("microservices_connected", infraStore.microservices_connected)
-    expect(spy).not.toHaveBeenCalled()
-  })
+describe("when_microservices_connected_run_function", () => {
   test("microservices not connected", async () => {
-    const geodeStore = useGeodeStore()
-    const viewerStore = useViewerStore()
-    const infraStore = useInfraStore()
     const spy = vi.spyOn(dumb_obj, "dumb_method")
     run_function_when_microservices_connected(dumb_obj.dumb_method)
-    await geodeStore.$patch({ status: Status.NOT_CONNECTED })
-    await viewerStore.$patch({ status: Status.NOT_CONNECTED })
-    console.log("geodeStore", geodeStore.status)
-    console.log("viewerStore", viewerStore.status)
-
-    console.log("microservices_connected", infraStore.microservices_connected)
+    geodeStore.$patch({ status: Status.NOT_CONNECTED })
+    viewerStore.$patch({ status: Status.NOT_CONNECTED })
     expect(spy).not.toHaveBeenCalled()
   })
 
   test("microservices connected", async () => {
-    const geodeStore = useGeodeStore()
-    const viewerStore = useViewerStore()
     const spy = vi.spyOn(dumb_obj, "dumb_method")
     run_function_when_microservices_connected(dumb_obj.dumb_method)
-    await geodeStore.$patch({ status: Status.CONNECTED })
-    await viewerStore.$patch({ status: Status.CONNECTED })
-    expect(spy).toHaveBeenCalled()
+    geodeStore.$patch({ status: Status.CONNECTED })
+    viewerStore.$patch({ status: Status.CONNECTED })
+    await flushPromises()
+    expect(spy).toHaveBeenCalledWith()
   })
 })

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

@@ -1,34 +1,30 @@
-import { describe, expect, test, beforeEach, vi } from "vitest"
-import { setActivePinia } from "pinia"
-import { createTestingPinia } from "@pinia/testing"
+// Third party imports
+import { beforeEach, describe, expect, test } from "vitest"
 import { registerEndpoint } from "@nuxt/test-utils/runtime"
-import upload_file from "@ogw_front/utils/upload_file"
 import schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
-import { useFeedbackStore } from "@ogw_front/stores/feedback"
 
+// Local imports
+import { setupActivePinia } from "../../utils"
+import upload_file from "@ogw_front/utils/upload_file"
+import { useFeedbackStore } from "@ogw_front/stores/feedback"
 import { useGeodeStore } from "@ogw_front/stores/geode"
+
+const ZERO = 0
 const schema = schemas.opengeodeweb_back.upload_file
 
-beforeEach(async () => {
-  const pinia = createTestingPinia({
-    stubActions: false,
-    createSpy: vi.fn,
-  })
-  setActivePinia(pinia)
+beforeEach(() => {
+  setupActivePinia()
+  const geodeStore = useGeodeStore()
+  geodeStore.base_url = ""
 })
 
-describe("upload_file", () => {
-  beforeEach(() => {
-    const geodeStore = useGeodeStore()
-    geodeStore.base_url = ""
-  })
-
-  test("Throw error", async () => {
-    var file = "toto"
+describe("upload_file test", () => {
+  test("throw error", async () => {
+    const file = "toto"
 
-    expect(async () => {
-      await upload_file({ route: schema.$id, file })
-    }).rejects.toThrowError("file must be a instance of File")
+    await expect(upload_file({ route: schema.$id, file })).rejects.toThrow(
+      "file must be a instance of File",
+    )
   })
 
   test("onResponse", async () => {
@@ -37,8 +33,8 @@ describe("upload_file", () => {
       method: "PUT",
       handler: () => ({ test: "ok" }),
     })
-    var file = new File(["fake_file"], "fake_file.txt")
-    var response_value
+    const file = new File(["fake_file"], "fake_file.txt")
+    let response_value = ""
     await upload_file(
       { route: schema.$id, file },
       {
@@ -47,7 +43,7 @@ describe("upload_file", () => {
         },
       },
     )
-    expect(feedbackStore.feedbacks.length).toBe(0)
+    expect(feedbackStore.feedbacks).toHaveLength(ZERO)
     expect(response_value).toBe("ok")
   })
 })

package/tests/unit/plugins/project_load.nuxt.test.js

@@ -1,16 +1,22 @@
 import { beforeEach, describe, expect, test, vi } from "vitest"
-import { createTestingPinia } from "@pinia/testing"
-import { setActivePinia } from "pinia"
-import { database } from "../../../internal/database/database.js"
 
-import { useTreeviewStore } from "@ogw_front/stores/treeview"
 import { useAppStore } from "@ogw_front/stores/app"
+import { useDataStore } from "@ogw_front/stores/data"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer"
-import { useDataStore } from "@ogw_front/stores/data"
+import { useTreeviewStore } from "@ogw_front/stores/treeview"
+
+import { database } from "../../../internal/database/database.js"
+import { setupActivePinia } from "../../utils"
+
+const PANEL_WIDTH = 320
+const Z_SCALE = 1.5
+const STORES_SLICE_START = 1
 
 vi.mock("../../../internal/utils/viewer_call", () => ({
-  viewer_call: vi.fn(() => Promise.resolve()),
+  viewer_call: vi.fn(async () => {
+    await Promise.resolve()
+  }),
 }))
 vi.mock("../../../app/stores/hybrid_viewer", () => ({
   useHybridViewerStore: () => ({
@@ -25,12 +31,7 @@ vi.mock("../../../app/stores/hybrid_viewer", () => ({
 }))
 
 beforeEach(() => {
-  setActivePinia(
-    createTestingPinia({
-      stubActions: false,
-      createSpy: vi.fn,
-    }),
-  )
+  setupActivePinia()
 })
 
 describe("Project import", () => {
@@ -42,15 +43,15 @@ describe("Project import", () => {
       dataStyle: useDataStyleStore(),
       hybrid: useHybridViewerStore(),
     }
-    Object.values(stores)
-      .slice(1)
-      .forEach((store) => stores.app.registerStore(store))
+    const storesArray = Object.values(stores)
+    for (const store of storesArray.slice(STORES_SLICE_START)) {
+      stores.app.registerStore(store)
+    }
 
     vi.spyOn(stores.dataBase, "importStores").mockImplementation(
       async (snapshot) => {
-        for (const item of snapshot?.items || []) {
-          await database.data.put(item)
-        }
+        const items = snapshot?.items || []
+        await Promise.all(items.map((item) => database.data.put(item)))
       },
     )
 
@@ -73,13 +74,13 @@ describe("Project import", () => {
         selection: [],
         components_selection: [],
         isAdditionnalTreeDisplayed: false,
-        panelWidth: 320,
+        panelWidth: PANEL_WIDTH,
         model_id: "",
         isTreeCollection: false,
-        selectedTree: null,
+        selectedTree: undefined,
       },
       dataStyle: { styles: { abc123: { some: "style" } } },
-      hybridViewer: { zScale: 1.5 },
+      hybridViewer: { zScale: Z_SCALE },
     }
 
     await stores.app.importStores(snapshot)

package/tests/unit/stores/App.nuxt.test.js

@@ -4,15 +4,19 @@ import { setActivePinia } from "pinia"
 
 import { useAppStore } from "@ogw_front/stores/app"
 
-beforeEach(async () => {
-  const pinia = createTestingPinia({
-    stubActions: false,
-    createSpy: vi.fn,
-  })
-  setActivePinia(pinia)
-})
+import { setupActivePinia } from "../../utils"
+
+// Constants
+const SINGLE_STORE_LENGTH = 1
+const MULTIPLE_STORES_LENGTH = 2
+const FIRST_INDEX = 0
+const SECOND_INDEX = 1
+const CALL_COUNT_ONCE = 1
 
-describe("App Store", () => {
+beforeEach(() => {
+  setupActivePinia()
+})
+describe("app store", () => {
   describe("state", () => {
     test("initial state", () => {
       const appStore = useAppStore()
@@ -30,38 +34,38 @@ describe("App Store", () => {
         const mock_store = {
           $id: "testStore",
           save: vi.fn().mockImplementation(() => ({ data: "test" })),
-          load: vi.fn().mockImplementation(() => {}),
+          load: vi.fn().mockImplementation(),
         }
 
         appStore.registerStore(mock_store)
 
-        expect(appStore.stores.length).toBe(1)
-        expect(appStore.stores[0]).toStrictEqual(mock_store)
+        expect(appStore.stores).toHaveLength(SINGLE_STORE_LENGTH)
+        expect(appStore.stores[FIRST_INDEX]).toStrictEqual(mock_store)
       })
 
       test("register multiple stores", () => {
         const appStore = useAppStore()
         const mock_store_1 = {
           $id: "userStore",
-          save: vi.fn().mockImplementation(() => {}),
-          load: vi.fn().mockImplementation(() => {}),
+          save: vi.fn().mockImplementation(),
+          load: vi.fn().mockImplementation(),
         }
         const mock_store_2 = {
           $id: "geodeStore",
-          save: vi.fn().mockImplementation(() => {}),
-          load: vi.fn().mockImplementation(() => {}),
+          save: vi.fn().mockImplementation(),
+          load: vi.fn().mockImplementation(),
         }
 
         appStore.registerStore(mock_store_1)
         appStore.registerStore(mock_store_2)
 
-        expect(appStore.stores.length).toBe(2)
-        expect(appStore.stores[0].$id).toBe("userStore")
-        expect(appStore.stores[1].$id).toBe("geodeStore")
+        expect(appStore.stores).toHaveLength(MULTIPLE_STORES_LENGTH)
+        expect(appStore.stores[FIRST_INDEX].$id).toBe("userStore")
+        expect(appStore.stores[SECOND_INDEX].$id).toBe("geodeStore")
       })
     })
 
-    describe("Export", () => {
+    describe("export", () => {
       test("export stores with exportStores method", async () => {
         const appStore = useAppStore()
         const mock_store_1 = {
@@ -70,14 +74,14 @@ describe("App Store", () => {
             name: "toto",
             email: "toto@titi.com",
           })),
-          importStores: vi.fn().mockImplementation(() => {}),
+          importStores: vi.fn().mockImplementation(),
         }
         const mock_store_2 = {
           $id: "geodeStore",
           exportStores: vi
             .fn()
             .mockImplementation(() => ({ items: [], total: 0 })),
-          importStores: vi.fn().mockImplementation(() => {}),
+          importStores: vi.fn().mockImplementation(),
         }
 
         appStore.registerStore(mock_store_1)
@@ -85,9 +89,9 @@ describe("App Store", () => {
 
         const snapshot = await appStore.exportStores()
 
-        expect(mock_store_1.exportStores).toHaveBeenCalledTimes(1)
-        expect(mock_store_2.exportStores).toHaveBeenCalledTimes(1)
-        expect(snapshot).toEqual({
+        expect(mock_store_1.exportStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE)
+        expect(mock_store_2.exportStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE)
+        expect(snapshot).toStrictEqual({
           userStore: { name: "toto", email: "toto@titi.com" },
           geodeStore: { items: [], total: 0 },
         })
@@ -98,11 +102,11 @@ describe("App Store", () => {
         const mock_store_1 = {
           $id: "withSave",
           exportStores: vi.fn().mockImplementation(() => ({ data: "test" })),
-          importStores: vi.fn().mockImplementation(() => {}),
+          importStores: vi.fn().mockImplementation(),
         }
         const mock_store_2 = {
           $id: "withoutSave",
-          importStores: vi.fn().mockImplementation(() => {}),
+          importStores: vi.fn().mockImplementation(),
         }
 
         appStore.registerStore(mock_store_1)
@@ -110,7 +114,7 @@ describe("App Store", () => {
 
         const snapshot = await appStore.exportStores()
 
-        expect(mock_store_1.exportStores).toHaveBeenCalledTimes(1)
+        expect(mock_store_1.exportStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE)
         expect(snapshot).toEqual({
           withSave: { data: "test" },
         })
@@ -120,12 +124,12 @@ describe("App Store", () => {
       test("return empty snapshot when no stores registered", async () => {
         const appStore = useAppStore()
         const snapshot = await appStore.exportStores()
-        expect(snapshot).toEqual({})
+        expect(snapshot).toStrictEqual({})
       })
     })
 
     describe("load", () => {
-      test("App Store > actions > importStores > import stores with importStores method", async () => {
+      test("import stores with importStores method", async () => {
         const appStore = useAppStore()
         const userStore = {
           $id: "userStore",
@@ -142,20 +146,20 @@ describe("App Store", () => {
           geodeStore: { other: "data" },
         }
         await appStore.importStores(snapshot)
-        expect(userStore.importStores).toHaveBeenCalledTimes(1)
-        expect(geodeStore.importStores).toHaveBeenCalledTimes(1)
+        expect(userStore.importStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE)
+        expect(geodeStore.importStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE)
       })
 
-      test("skip stores without importStores method", () => {
+      test("skip stores without importStores method", async () => {
         const appStore = useAppStore()
         const mock_store_1 = {
           $id: "withImport",
-          save: vi.fn().mockImplementation(() => {}),
-          importStores: vi.fn().mockImplementation(() => {}),
+          save: vi.fn().mockImplementation(),
+          importStores: vi.fn().mockImplementation(),
         }
         const mock_store_2 = {
           $id: "withoutImport",
-          save: vi.fn().mockImplementation(() => {}),
+          save: vi.fn().mockImplementation(),
         }
         appStore.registerStore(mock_store_1)
         appStore.registerStore(mock_store_2)
@@ -163,22 +167,20 @@ describe("App Store", () => {
           withImport: { data: "test" },
           withoutImport: { data: "ignored" },
         }
-        appStore.importStores(snapshot)
-        expect(mock_store_1.importStores).toHaveBeenCalledTimes(1)
+        await appStore.importStores(snapshot)
+        expect(mock_store_1.importStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE)
         expect(mock_store_2.importStores).toBeUndefined()
       })
 
-      test("warn when store not found in snapshot", () => {
+      test("warn when store not found in snapshot", async () => {
         const appStore = useAppStore()
-        const console_warn_spy = vi
-          .spyOn(console, "warn")
-          .mockImplementation(() => {})
+        const console_warn_spy = vi.spyOn(console, "warn").mockImplementation()
         const mock_store = {
           $id: "testStore",
-          importStores: vi.fn().mockImplementation(() => {}),
+          importStores: vi.fn().mockImplementation(),
         }
         appStore.registerStore(mock_store)
-        appStore.importStores({})
+        await appStore.importStores({})
         expect(console_warn_spy).toHaveBeenCalledWith(
           expect.stringContaining("Stores not found in snapshot: testStore"),
         )

package/tests/unit/stores/Feedback.nuxt.test.js

@@ -1,14 +1,12 @@
-import { setActivePinia } from "pinia"
-import { createTestingPinia } from "@pinia/testing"
+// Third party imports
+import { beforeEach, describe, expect, expectTypeOf, test } from "vitest"
+
+// Local imports
+import { setupActivePinia } from "../../utils"
 import { useFeedbackStore } from "@ogw_front/stores/feedback"
-import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest"
 
-beforeEach(async () => {
-  const pinia = createTestingPinia({
-    stubActions: false,
-    createSpy: vi.fn,
-  })
-  setActivePinia(pinia)
+beforeEach(() => {
+  setupActivePinia()
 })
 
 describe("Feedback Store", () => {
@@ -19,6 +17,7 @@ describe("Feedback Store", () => {
       expectTypeOf(feedbackStore.server_error).toBeBoolean()
     })
   })
+
   describe("actions", () => {
     describe("add_error", () => {
       test("test add_error", () => {
@@ -29,12 +28,10 @@ describe("Feedback Store", () => {
           "test message",
           "test description",
         )
-        expect(feedbackStore.feedbacks.length).toBe(1)
+        expect(feedbackStore.feedbacks).toHaveLength(1)
         expect(feedbackStore.feedbacks[0].type).toBe("error")
       })
-    })
 
-    describe("add_error", () => {
       test("test feedbacks_timeout", () => {
         const feedbackStore = useFeedbackStore()
         feedbackStore.feedbacks_timeout_miliseconds = 500
@@ -44,9 +41,9 @@ describe("Feedback Store", () => {
           "test message",
           "test description",
         )
-        expect(feedbackStore.feedbacks.length).toBe(1)
+        expect(feedbackStore.feedbacks).toHaveLength(1)
         setTimeout(() => {
-          expect(feedbackStore.feedbacks.length).toBe(0)
+          expect(feedbackStore.feedbacks).toHaveLength(0)
         }, 1000)
       })
     })
@@ -56,19 +53,20 @@ describe("Feedback Store", () => {
         const feedbackStore = useFeedbackStore()
         feedbackStore.feedbacks_timeout_miliseconds = 500
         feedbackStore.add_success("test description")
-        expect(feedbackStore.feedbacks.length).toBe(1)
+        expect(feedbackStore.feedbacks).toHaveLength(1)
         expect(feedbackStore.feedbacks[0].type).toBe("success")
 
         setTimeout(() => {
-          expect(feedbackStore.feedbacks.length).toBe(0)
+          expect(feedbackStore.feedbacks).toHaveLength(0)
         }, 1000)
       })
     })
+
     describe("delete_feedback", () => {
       test("test", () => {
         const feedbackStore = useFeedbackStore()
         feedbackStore.delete_feedback(0)
-        expect(feedbackStore.feedbacks.length).toBe(0)
+        expect(feedbackStore.feedbacks).toHaveLength(0)
       })
     })
 
@@ -77,7 +75,7 @@ describe("Feedback Store", () => {
         const feedbackStore = useFeedbackStore()
         feedbackStore.$patch({ server_error: true })
         feedbackStore.delete_server_error()
-        expect(feedbackStore.server_error).toBe(false)
+        expect(feedbackStore.server_error).toBeFalsy()
       })
     })
   })