@geode/opengeodeweb-front 10.0.2-rc.1 → 10.0.2-rc.2

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

@@ -64,11 +64,11 @@ const geodeStoreMock = {
 const infraStoreMock = {
   app_mode: appMode.BROWSER,
   ID: "1234",
-  create_connection: vi.fn(() => Promise.resolve()),
 }
 const viewerStoreMock = {
   ws_connect: vi.fn(() => Promise.resolve()),
   base_url: vi.fn(() => ""),
+  request: vi.fn(() => Promise.resolve()),
 }
 const treeviewStoreMock = {
   clear: vi.fn(),
@@ -91,13 +91,14 @@ const hybridViewerStoreMock = {
   clear: vi.fn(),
   initHybridViewer: vi.fn(() => Promise.resolve()),
   importStores: vi.fn(async (snapshot) => {
-    if (snapshot?.zScale != null)
+    if (snapshot?.zScale != null) {
       hybridViewerStoreMock.setZScaling(snapshot.zScale)
+    }
     if (snapshot?.camera_options) {
       const { viewer_call } =
-        await import("@ogw_front/composables/viewer_call.js")
+        await import("../../../internal/utils/viewer_call.js")
       viewer_call({
-        schema: { $id: "opengeodeweb_viewer/viewer.update_camera" },
+        schema: { $id: "opengeodeweb_viewer.viewer.update_camera" },
         params: { camera_options: snapshot.camera_options },
       })
       hybridViewerStoreMock.remoteRender()
@@ -113,7 +114,7 @@ vi.stubGlobal(
   "$fetch",
   vi.fn(async () => ({ snapshot: snapshotMock })),
 )
-vi.mock("@ogw_front/composables/viewer_call.js", () => ({
+vi.mock("../../../internal/utils/viewer_call.js", () => ({
   viewer_call: vi.fn(() => Promise.resolve()),
 }))
 
@@ -179,7 +180,6 @@ describe("ProjectManager composable (compact)", () => {
 
     // reset spies
     for (const store of [
-      infraStoreMock,
       viewerStoreMock,
       treeviewStoreMock,
       dataBaseStoreMock,
@@ -191,7 +191,7 @@ describe("ProjectManager composable (compact)", () => {
       )
     }
     const { viewer_call } =
-      await import("@ogw_front/composables/viewer_call.js")
+      await import("../../../internal/utils/viewer_call.js")
     viewer_call.mockClear()
   })
 
@@ -201,7 +201,6 @@ describe("ProjectManager composable (compact)", () => {
 
     await exportProject()
 
-    expect(infraStoreMock.create_connection).toHaveBeenCalled()
     expect(fileDownload).toHaveBeenCalled()
   })
 
@@ -214,11 +213,10 @@ describe("ProjectManager composable (compact)", () => {
     await importProjectFile(file)
 
     const { viewer_call } =
-      await import("@ogw_front/composables/viewer_call.js")
+      await import("../../../internal/utils/viewer_call.js")
 
-    expect(infraStoreMock.create_connection).toHaveBeenCalled()
     expect(viewerStoreMock.ws_connect).toHaveBeenCalled()
-    expect(viewer_call).toHaveBeenCalledTimes(3)
+    expect(viewer_call).toHaveBeenCalledTimes(2)
 
     expect(treeviewStoreMock.importStores).toHaveBeenCalledWith(
       snapshotMock.treeview,

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

@@ -3,15 +3,15 @@ import { setActivePinia } from "pinia"
 import { createTestingPinia } from "@pinia/testing"
 import { registerEndpoint } from "@nuxt/test-utils/runtime"
 
-describe("api_fetch", () => {
+describe("geodeStore.request()", () => {
   const pinia = createTestingPinia({
     stubActions: false,
     createSpy: vi.fn,
   })
   setActivePinia(pinia)
-  const geode_store = useGeodeStore()
+  const geodeStore = useGeodeStore()
   const feedback_store = useFeedbackStore()
-  geode_store.base_url = ""
+  geodeStore.base_url = ""
 
   const schema = {
     $id: "/test",
@@ -28,8 +28,8 @@ describe("api_fetch", () => {
 
   beforeEach(async () => {
     await feedback_store.$reset()
-    await geode_store.$reset()
-    geode_store.base_url = ""
+    await geodeStore.$reset()
+    geodeStore.base_url = ""
   })
 
   // test("valid schema and params", async () => {
@@ -52,55 +52,32 @@ describe("api_fetch", () => {
       additionalProperties: false,
     }
     const params = { test: "hello" }
-    expect(() => api_fetch({ schema, params })).toThrowError(
+    expect(() => geodeStore.request(schema, params)).toThrowError(
       "data/test must be number",
     )
   })
 
   test("invalid params", async () => {
-    const schema = {
-      $id: "/test",
-      type: "object",
-      methods: ["POST"],
-      properties: {
-        test: {
-          type: "string",
-        },
-      },
-      required: ["test"],
-      additionalProperties: false,
-    }
     const params = {}
-    expect(() => api_fetch({ schema, params })).toThrowError(
+    expect(() => geodeStore.request(schema, params)).toThrowError(
       "data must have required property 'test'",
     )
   })
-  test("request error handling", async () => {
-    const schema = {
-      $id: "/test",
-      type: "object",
-      methods: ["POST"],
-      properties: {
-        test: {
-          type: "string",
-        },
-      },
-      required: ["test"],
-      additionalProperties: false,
-    }
+
+  test("request with callbacks", async () => {
     const params = { test: "hello" }
-    async function request_error_function() {
-      console.log("request_error_function")
+    let errorCalled = false
+    const callbacks = {
+      request_error_function: async () => {
+        errorCalled = true
+      },
     }
-    const spy = vi.fn(request_error_function)
     registerEndpoint(schema.$id, {
       method: schema.methods[0],
-      handler: () => ({ return: "toto" }),
+      handler: () => ({ result: "success" }),
     })
-    await api_fetch({ schema, params }, { request_error_function })
-    // expect(feedback_store.feedbacks.length).toBe(1)
-    await request_error_function()
-    // expect(spy).toHaveBeenCalledTimes(1)
+    await geodeStore.request(schema, params, callbacks)
+    expect(errorCalled).toBe(false)
   })
 
   // test("response handling", async () => {

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

@@ -16,28 +16,43 @@ describe("run_function_when_microservices_connected", () => {
   const dumb_obj = { dumb_method: () => true }
 
   beforeEach(async () => {
-    const geode_store = useGeodeStore()
-    const viewer_store = useViewerStore()
-    await geode_store.$patch({ status: Status.NOT_CONNECTED })
-    await viewer_store.$patch({ status: Status.NOT_CONNECTED })
+    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 })
   })
+
   test("microservices connected", async () => {
-    const geode_store = useGeodeStore()
-    const viewer_store = useViewerStore()
+    const geodeStore = useGeodeStore()
+    const viewerStore = useViewerStore()
     const spy = vi.spyOn(dumb_obj, "dumb_method")
     run_function_when_microservices_connected(dumb_obj.dumb_method)
-    await geode_store.$patch({ status: Status.CONNECTED })
-    await viewer_store.$patch({ status: Status.CONNECTED })
+    await geodeStore.$patch({ status: Status.CONNECTED })
+    await viewerStore.$patch({ status: Status.CONNECTED })
     expect(spy).toHaveBeenCalled()
   })
 
   test("microservices not connected", async () => {
-    const geode_store = useGeodeStore()
-    const viewer_store = useViewerStore()
+    const geodeStore = useGeodeStore()
+    const viewerStore = useViewerStore()
     const spy = vi.spyOn(dumb_obj, "dumb_method")
     run_function_when_microservices_connected(dumb_obj.dumb_method)
-    await geode_store.$patch({ status: Status.NOT_CONNECTED })
-    await viewer_store.$patch({ status: Status.NOT_CONNECTED })
+    await geodeStore.$patch({ status: Status.NOT_CONNECTED })
+    await viewerStore.$patch({ status: Status.NOT_CONNECTED })
     expect(spy).not.toHaveBeenCalled()
   })
 })

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

@@ -2,7 +2,7 @@ import { describe, expect, test, beforeEach, vi } from "vitest"
 import { setActivePinia } from "pinia"
 import { createTestingPinia } from "@pinia/testing"
 import { registerEndpoint } from "@nuxt/test-utils/runtime"
-import { upload_file } from "@ogw_front/composables/upload_file"
+import upload_file from "@ogw_front/utils/upload_file"
 import schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
 const schema = schemas.opengeodeweb_back.upload_file
 
@@ -16,8 +16,8 @@ beforeEach(async () => {
 
 describe("upload_file.js", () => {
   beforeEach(() => {
-    const geode_store = useGeodeStore()
-    geode_store.base_url = ""
+    const geodeStore = useGeodeStore()
+    geodeStore.base_url = ""
   })
 
   test("Throw error", async () => {

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

@@ -2,9 +2,8 @@ import { beforeEach, describe, expect, test, vi } from "vitest"
 import { createTestingPinia } from "@pinia/testing"
 import { setActivePinia } from "pinia"
 
-vi.mock("@ogw_front/composables/viewer_call.js", () => ({
-  default: vi.fn(() => Promise.resolve({})),
-  viewer_call: vi.fn(() => Promise.resolve({})),
+vi.mock("../../../internal/utils/viewer_call.js", () => ({
+  viewer_call: vi.fn(() => Promise.resolve()),
 }))
 vi.mock("@/stores/hybrid_viewer.js", () => ({
   useHybridViewerStore: () => ({

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

@@ -17,10 +17,10 @@ beforeEach(async () => {
 describe("Geode store", () => {
   describe("state", () => {
     test("initial state", () => {
-      const geode_store = useGeodeStore()
-      expectTypeOf(geode_store.default_local_port).toBeString()
-      expectTypeOf(geode_store.request_counter).toBeNumber()
-      expectTypeOf(geode_store.status).toBeString()
+      const geodeStore = useGeodeStore()
+      expectTypeOf(geodeStore.default_local_port).toBeString()
+      expectTypeOf(geodeStore.request_counter).toBeNumber()
+      expectTypeOf(geodeStore.status).toBeString()
     })
   })
 
@@ -28,78 +28,76 @@ describe("Geode store", () => {
     describe("protocol", () => {
       test("test app_mode CLOUD", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
+        const geodeStore = useGeodeStore()
         infra_store.app_mode = appMode.CLOUD
-        expect(geode_store.protocol).toBe("https")
+        expect(geodeStore.protocol).toBe("https")
       })
       test("test app_mode BROWSER", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
+        const geodeStore = useGeodeStore()
         infra_store.app_mode = appMode.BROWSER
-        expect(geode_store.protocol).toBe("http")
+        expect(geodeStore.protocol).toBe("http")
       })
       test("test app_mode DESKTOP", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
+        const geodeStore = useGeodeStore()
         infra_store.app_mode = appMode.DESKTOP
-        expect(geode_store.protocol).toBe("http")
+        expect(geodeStore.protocol).toBe("http")
       })
     })
 
     describe("port", () => {
       test("test app_mode CLOUD", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
+        const geodeStore = useGeodeStore()
         infra_store.app_mode = appMode.CLOUD
-        expect(geode_store.port).toBe("443")
+        expect(geodeStore.port).toBe("443")
       })
       test("test app_mode BROWSER", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
+        const geodeStore = useGeodeStore()
         infra_store.app_mode = appMode.BROWSER
-        expect(geode_store.port).toBe(geode_store.default_local_port)
+        expect(geodeStore.port).toBe(geodeStore.default_local_port)
       })
       test("test app_mode DESKTOP", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
+        const geodeStore = useGeodeStore()
         infra_store.app_mode = appMode.DESKTOP
-        expect(geode_store.port).toBe(geode_store.default_local_port)
+        expect(geodeStore.port).toBe(geodeStore.default_local_port)
       })
 
       test("test override default_local_port", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
+        const geodeStore = useGeodeStore()
         infra_store.app_mode = appMode.DESKTOP
-        geode_store.default_local_port = "12"
-        expect(geode_store.port).toBe("12")
+        geodeStore.default_local_port = "12"
+        expect(geodeStore.port).toBe("12")
       })
     })
 
     describe("base_url", () => {
       test("test app_mode BROWSER", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
+        const geodeStore = useGeodeStore()
         infra_store.app_mode = appMode.BROWSER
         infra_store.domain_name = "localhost"
-        expect(geode_store.base_url).toBe("http://localhost:5000")
+        expect(geodeStore.base_url).toBe("http://localhost:5000")
       })
       test("test app_mode CLOUD", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
+        const geodeStore = useGeodeStore()
         infra_store.app_mode = appMode.CLOUD
         infra_store.ID = "123456"
         infra_store.domain_name = "example.com"
-        expect(geode_store.base_url).toBe(
-          "https://example.com:443/123456/geode",
-        )
+        expect(geodeStore.base_url).toBe("https://example.com:443/123456/geode")
       })
       test("test app_mode CLOUD, ID empty", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
+        const geodeStore = useGeodeStore()
         infra_store.app_mode = appMode.CLOUD
         infra_store.ID = ""
         infra_store.domain_name = "example.com"
-        expect(() => geode_store.base_url).toThrowError(
+        expect(() => geodeStore.base_url).toThrowError(
           "ID must not be empty in cloud mode",
         )
       })
@@ -107,14 +105,14 @@ describe("Geode store", () => {
 
     describe("is_busy", () => {
       test("test is_busy", () => {
-        const geode_store = useGeodeStore()
-        geode_store.request_counter = 1
-        expect(geode_store.is_busy).toBe(true)
+        const geodeStore = useGeodeStore()
+        geodeStore.request_counter = 1
+        expect(geodeStore.is_busy).toBe(true)
       })
       test("test not is_busy", () => {
-        const geode_store = useGeodeStore()
-        geode_store.request_counter = 0
-        expect(geode_store.is_busy).toBe(false)
+        const geodeStore = useGeodeStore()
+        geodeStore.request_counter = 0
+        expect(geodeStore.is_busy).toBe(false)
       })
     })
   })
@@ -125,40 +123,40 @@ describe("Geode store", () => {
       registerEndpoint(back_schemas.opengeodeweb_back.ping.$id, getFakeCall)
 
       test("response", async () => {
-        const geode_store = useGeodeStore()
-        geode_store.base_url = ""
+        const geodeStore = useGeodeStore()
+        geodeStore.base_url = ""
         getFakeCall.mockImplementation(() => ({}))
-        await geode_store.do_ping()
-        expect(geode_store.status).toBe(Status.CONNECTED)
+        await geodeStore.do_ping()
+        expect(geodeStore.status).toBe(Status.CONNECTED)
       })
       test("response_error", async () => {
-        const geode_store = useGeodeStore()
-        geode_store.base_url = ""
+        const geodeStore = useGeodeStore()
+        geodeStore.base_url = ""
         getFakeCall.mockImplementation(() => {
           throw createError({
             status: 500,
           })
         })
 
-        await geode_store.do_ping()
-        expect(geode_store.status).toBe(Status.NOT_CONNECTED)
+        await geodeStore.do_ping()
+        expect(geodeStore.status).toBe(Status.NOT_CONNECTED)
       })
     })
 
     describe("start_request", () => {
       test("test increment", async () => {
-        const geode_store = useGeodeStore()
-        expect(geode_store.request_counter).toBe(0)
-        await geode_store.start_request()
-        expect(geode_store.request_counter).toBe(1)
+        const geodeStore = useGeodeStore()
+        expect(geodeStore.request_counter).toBe(0)
+        await geodeStore.start_request()
+        expect(geodeStore.request_counter).toBe(1)
       })
     })
     describe("stop_request", () => {
       test("test decrement", async () => {
-        const geode_store = useGeodeStore()
-        geode_store.request_counter = 1
-        await geode_store.stop_request()
-        expect(geode_store.request_counter).toBe(0)
+        const geodeStore = useGeodeStore()
+        geodeStore.request_counter = 1
+        await geodeStore.stop_request()
+        expect(geodeStore.request_counter).toBe(0)
       })
     })
   })