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

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

@@ -64,103 +64,229 @@ describe("Infra Store", () => {
       })
     })
 
-    describe("lambda_url", () => {
-      test("test is cloud true", () => {
+    describe("microservices_connected", () => {
+      test("test no microservices registered", () => {
         const infra_store = useInfraStore()
-        useRuntimeConfig().public.SITE_BRANCH = "/test"
-        useRuntimeConfig().public.PROJECT = "/project"
-        infra_store.app_mode = appMode.CLOUD
-        expect(infra_store.lambda_url).toBe(
-          "https://api.geode-solutions.com:443/test/project/createbackend",
-        )
+        expect(infra_store.microservices_connected).toBe(true)
       })
-    })
-    describe("status", () => {
       test("test geode false & viewer false", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
-        const viewer_store = useViewerStore()
-        geode_store.$patch({ status: Status.NOT_CONNECTED })
-        viewer_store.$patch({ status: Status.NOT_CONNECTED })
+        const geodeStore = useGeodeStore()
+        const viewerStore = useViewerStore()
+
+        infra_store.register_microservice(geodeStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+        infra_store.register_microservice(viewerStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+
+        geodeStore.$patch({ status: Status.NOT_CONNECTED })
+        viewerStore.$patch({ status: Status.NOT_CONNECTED })
         expect(infra_store.microservices_connected).toBe(false)
       })
       test("test geode true & viewer false", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
-        const viewer_store = useViewerStore()
-        geode_store.$patch({ status: Status.CONNECTED })
-        viewer_store.$patch({ status: Status.NOT_CONNECTED })
+        const geodeStore = useGeodeStore()
+        const viewerStore = useViewerStore()
+
+        infra_store.register_microservice(geodeStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+        infra_store.register_microservice(viewerStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+
+        geodeStore.$patch({ status: Status.CONNECTED })
+        viewerStore.$patch({ status: Status.NOT_CONNECTED })
         expect(infra_store.microservices_connected).toBe(false)
       })
       test("test geode false & viewer true", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
-        const viewer_store = useViewerStore()
-        geode_store.$patch({ status: Status.NOT_CONNECTED })
-        viewer_store.$patch({ status: Status.CONNECTED })
+        const geodeStore = useGeodeStore()
+        const viewerStore = useViewerStore()
+
+        infra_store.register_microservice(geodeStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+        infra_store.register_microservice(viewerStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+
+        geodeStore.$patch({ status: Status.NOT_CONNECTED })
+        viewerStore.$patch({ status: Status.CONNECTED })
         expect(infra_store.microservices_connected).toBe(false)
       })
       test("test geode true & viewer true", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
-        const viewer_store = useViewerStore()
-        geode_store.$patch({ status: Status.CONNECTED })
-        viewer_store.$patch({ status: Status.CONNECTED })
+        const geodeStore = useGeodeStore()
+        const viewerStore = useViewerStore()
+
+        infra_store.register_microservice(geodeStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+        infra_store.register_microservice(viewerStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+
+        geodeStore.$patch({ status: Status.CONNECTED })
+        viewerStore.$patch({ status: Status.CONNECTED })
         expect(infra_store.microservices_connected).toBe(true)
       })
     })
 
-    describe("is_busy", () => {
+    describe("microservices_busy", () => {
+      test("test no microservices registered", () => {
+        const infra_store = useInfraStore()
+        expect(infra_store.microservices_busy).toBe(false)
+      })
       test("test geode false & viewer false", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
-        const viewer_store = useViewerStore()
-        geode_store.$patch({ request_counter: 0 })
-        viewer_store.$patch({ request_counter: 0 })
+        const geodeStore = useGeodeStore()
+        const viewerStore = useViewerStore()
+
+        infra_store.register_microservice(geodeStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+        infra_store.register_microservice(viewerStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+
+        geodeStore.$patch({ request_counter: 0 })
+        viewerStore.$patch({ request_counter: 0 })
         expect(infra_store.microservices_busy).toBe(false)
       })
       test("test geode true & viewer false", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
-        const viewer_store = useViewerStore()
-        geode_store.$patch({ request_counter: 1 })
-        viewer_store.$patch({ request_counter: 0 })
+        const geodeStore = useGeodeStore()
+        const viewerStore = useViewerStore()
+
+        infra_store.register_microservice(geodeStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+        infra_store.register_microservice(viewerStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+
+        geodeStore.$patch({ request_counter: 1 })
+        viewerStore.$patch({ request_counter: 0 })
         expect(infra_store.microservices_busy).toBe(true)
       })
       test("test geode false & viewer true", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
-        const viewer_store = useViewerStore()
-        geode_store.$patch({ request_counter: 0 })
-        viewer_store.$patch({ request_counter: 1 })
+        const geodeStore = useGeodeStore()
+        const viewerStore = useViewerStore()
+
+        infra_store.register_microservice(geodeStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+        infra_store.register_microservice(viewerStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+
+        geodeStore.$patch({ request_counter: 0 })
+        viewerStore.$patch({ request_counter: 1 })
         expect(infra_store.microservices_busy).toBe(true)
       })
       test("test geode true & viewer true", () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
-        const viewer_store = useViewerStore()
-        geode_store.$patch({ request_counter: 1 })
-        viewer_store.$patch({ request_counter: 1 })
+        const geodeStore = useGeodeStore()
+        const viewerStore = useViewerStore()
+
+        infra_store.register_microservice(geodeStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+        infra_store.register_microservice(viewerStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+
+        geodeStore.$patch({ request_counter: 1 })
+        viewerStore.$patch({ request_counter: 1 })
         expect(infra_store.microservices_busy).toBe(true)
       })
     })
   })
 
   describe("actions", () => {
+    describe("register_microservice", () => {
+      test("register geode microservice", () => {
+        const infra_store = useInfraStore()
+        const geodeStore = useGeodeStore()
+
+        infra_store.register_microservice(geodeStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+
+        expect(infra_store.microservices.length).toBe(1)
+        expect(infra_store.microservices[0].$id).toBe("geode")
+      })
+
+      test("register multiple microservices", () => {
+        const infra_store = useInfraStore()
+        const geodeStore = useGeodeStore()
+        const viewerStore = useViewerStore()
+
+        infra_store.register_microservice(geodeStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+
+        infra_store.register_microservice(viewerStore, {
+          request: vi.fn(),
+          connect: vi.fn(),
+          launch: vi.fn(),
+        })
+
+        expect(infra_store.microservices.length).toBe(2)
+      })
+    })
+
     describe("create_backend", () => {
-      test("test without end-point", async () => {
+      test("test without microservices", async () => {
         const infra_store = useInfraStore()
-        const geode_store = useGeodeStore()
-        const viewer_store = useViewerStore()
+        infra_store.app_mode = appMode.BROWSER
         await infra_store.create_backend()
-        expect(infra_store.status).toBe(Status.NOT_CREATED)
-        expect(geode_store.status).toBe(Status.NOT_CONNECTED)
-        expect(viewer_store.status).toBe(Status.NOT_CONNECTED)
+        expect(infra_store.status).toBe(Status.CREATED)
       })
       // test("test with end-point", async () => {
       //   const infra_store = useInfraStore()
-      //   const geode_store = useGeodeStore()
-      //   const viewer_store = useViewerStore()
+      //   const geodeStore = useGeodeStore()
+      //   const viewerStore = useViewerStore()
       //   const feedback_store = useFeedbackStore()
 
       //   registerEndpoint(infra_store.lambda_url, {
@@ -169,8 +295,8 @@ describe("Infra Store", () => {
       //   })
       //   await infra_store.create_backend()
       //   expect(infra_store.status).toBe(Status.CREATED)
-      //   expect(geode_store.status).toBe(Status.NOT_CONNECTED)
-      //   expect(viewer_store.status).toBe(Status.NOT_CONNECTED)
+      //   expect(geodeStore.status).toBe(Status.NOT_CONNECTED)
+      //   expect(viewerStore.status).toBe(Status.NOT_CONNECTED)
       //   expect(feedback_store.server_error).toBe(true)
       // })
     })

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

@@ -0,0 +1,131 @@
+// Global imports
+
+// Third party imports
+import { registerEndpoint } from "@nuxt/test-utils/runtime"
+import { setActivePinia } from "pinia"
+import { createTestingPinia } from "@pinia/testing"
+import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest"
+
+// Local imports
+import Status from "@ogw_front/utils/status.js"
+
+beforeEach(async () => {
+  const pinia = createTestingPinia({
+    stubActions: false,
+    createSpy: vi.fn,
+  })
+  setActivePinia(pinia)
+})
+
+describe("Lambda Store", () => {
+  describe("state", () => {
+    test("initial state", () => {
+      const lambdaStore = useLambdaStore()
+      expectTypeOf(lambdaStore.status).toBeString()
+      expect(lambdaStore.status).toBe(Status.NOT_CONNECTED)
+    })
+  })
+
+  describe("getters", () => {
+    describe("protocol", () => {
+      test("test protocol is always https", () => {
+        const lambdaStore = useLambdaStore()
+        expect(lambdaStore.protocol).toBe("https")
+      })
+    })
+
+    describe("port", () => {
+      test("test port is always 443", () => {
+        const lambdaStore = useLambdaStore()
+        expect(lambdaStore.port).toBe("443")
+      })
+    })
+
+    describe("base_url", () => {
+      test("test base_url construction", () => {
+        const lambdaStore = useLambdaStore()
+        useRuntimeConfig().public.API_URL = "api.example.com"
+        useRuntimeConfig().public.SITE_BRANCH = "/test"
+        useRuntimeConfig().public.PROJECT = "/project"
+        expect(lambdaStore.base_url).toBe(
+          "https://api.example.com:443/test/project/createbackend",
+        )
+      })
+    })
+
+    describe("is_busy", () => {
+      test("test is_busy is always false", () => {
+        const lambdaStore = useLambdaStore()
+        expect(lambdaStore.is_busy).toBe(false)
+      })
+    })
+  })
+
+  describe("actions", () => {
+    describe("launch", () => {
+      const postFakeCall = vi.fn()
+
+      test("successful launch", async () => {
+        const lambdaStore = useLambdaStore()
+        const feedbackStore = useFeedbackStore()
+
+        useRuntimeConfig().public.API_URL = "api.example.com"
+        useRuntimeConfig().public.SITE_BRANCH = "/test"
+        useRuntimeConfig().public.PROJECT = "/project"
+
+        registerEndpoint(lambdaStore.base_url, {
+          method: "POST",
+          handler: postFakeCall,
+        })
+
+        postFakeCall.mockImplementation(() => ({
+          ID: "test-id-123456",
+        }))
+
+        const id = await lambdaStore.launch()
+
+        expect(lambdaStore.status).toBe(Status.CONNECTED)
+        expect(id).toBe("test-id-123456")
+        expect(feedbackStore.server_error).toBe(false)
+      })
+
+      test("failed launch - error response", async () => {
+        const lambdaStore = useLambdaStore()
+        const feedbackStore = useFeedbackStore()
+
+        useRuntimeConfig().public.API_URL = "api.example.com"
+        useRuntimeConfig().public.SITE_BRANCH = "/test"
+        useRuntimeConfig().public.PROJECT = "/project"
+
+        registerEndpoint(lambdaStore.base_url, {
+          method: "POST",
+          handler: postFakeCall,
+        })
+
+        postFakeCall.mockImplementation(() => {
+          throw createError({
+            status: 500,
+            statusMessage: "Internal Server Error",
+          })
+        })
+
+        await expect(lambdaStore.launch()).rejects.toThrow(
+          "Failed to launch lambda backend",
+        )
+
+        expect(lambdaStore.status).toBe(Status.NOT_CONNECTED)
+        expect(feedbackStore.server_error).toBe(true)
+      })
+    })
+
+    describe("connect", () => {
+      test("successful connect", async () => {
+        const lambdaStore = useLambdaStore()
+
+        await lambdaStore.connect()
+
+        expect(lambdaStore.status).toBe(Status.CONNECTED)
+      })
+    })
+  })
+})

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

@@ -55,16 +55,16 @@ beforeEach(() => {
 describe("Viewer Store", () => {
   describe("state", () => {
     test("initial state", () => {
-      const viewer_store = useViewerStore()
-      expectTypeOf(viewer_store.default_local_port).toBeString()
-      expectTypeOf(viewer_store.client).toEqualTypeOf({})
-      expectTypeOf(viewer_store.picking_mode).toBeBoolean()
-      expectTypeOf(viewer_store.picked_point).toEqualTypeOf({
+      const viewerStore = useViewerStore()
+      expectTypeOf(viewerStore.default_local_port).toBeString()
+      expectTypeOf(viewerStore.client).toEqualTypeOf({})
+      expectTypeOf(viewerStore.picking_mode).toBeBoolean()
+      expectTypeOf(viewerStore.picked_point).toEqualTypeOf({
         x: null,
         y: null,
       })
-      expectTypeOf(viewer_store.picked_point).toBeNumber()
-      expectTypeOf(viewer_store.status).toBeString()
+      expectTypeOf(viewerStore.picked_point).toBeNumber()
+      expectTypeOf(viewerStore.status).toBeString()
     })
   })
 
@@ -72,50 +72,50 @@ describe("Viewer Store", () => {
     describe("protocol", () => {
       test("test app_mode CLOUD", () => {
         const infra_store = useInfraStore()
-        const viewer_store = useViewerStore()
+        const viewerStore = useViewerStore()
         infra_store.app_mode = appMode.CLOUD
-        expect(viewer_store.protocol).toBe("wss")
+        expect(viewerStore.protocol).toBe("wss")
       })
       test("test app_mode BROWSER", () => {
         const infra_store = useInfraStore()
-        const viewer_store = useViewerStore()
+        const viewerStore = useViewerStore()
         infra_store.app_mode = appMode.BROWSER
-        expect(viewer_store.protocol).toBe("ws")
+        expect(viewerStore.protocol).toBe("ws")
       })
       test("test app_mode DESKTOP", () => {
         const infra_store = useInfraStore()
-        const viewer_store = useViewerStore()
+        const viewerStore = useViewerStore()
         infra_store.app_mode = appMode.DESKTOP
-        expect(viewer_store.protocol).toBe("ws")
+        expect(viewerStore.protocol).toBe("ws")
       })
     })
 
     describe("port", () => {
       test("test app_mode CLOUD", () => {
         const infra_store = useInfraStore()
-        const viewer_store = useViewerStore()
+        const viewerStore = useViewerStore()
         infra_store.app_mode = appMode.CLOUD
-        expect(viewer_store.port).toBe("443")
+        expect(viewerStore.port).toBe("443")
       })
       test("test app_mode BROWSER", () => {
         const infra_store = useInfraStore()
-        const viewer_store = useViewerStore()
+        const viewerStore = useViewerStore()
         infra_store.app_mode = appMode.BROWSER
-        expect(viewer_store.port).toBe(viewer_store.default_local_port)
+        expect(viewerStore.port).toBe(viewerStore.default_local_port)
       })
       test("test app_mode DESKTOP", () => {
         const infra_store = useInfraStore()
-        const viewer_store = useViewerStore()
+        const viewerStore = useViewerStore()
         infra_store.app_mode = appMode.DESKTOP
-        expect(viewer_store.port).toBe(viewer_store.default_local_port)
+        expect(viewerStore.port).toBe(viewerStore.default_local_port)
       })
 
       test("test override default_local_port", () => {
         const infra_store = useInfraStore()
-        const viewer_store = useViewerStore()
+        const viewerStore = useViewerStore()
         infra_store.app_mode = appMode.DESKTOP
-        viewer_store.default_local_port = "8080"
-        expect(viewer_store.port).toBe("8080")
+        viewerStore.default_local_port = "8080"
+        expect(viewerStore.port).toBe("8080")
       })
     })
     describe("base_url", () => {
@@ -123,48 +123,48 @@ describe("Viewer Store", () => {
         const infra_store = useInfraStore()
         infra_store.app_mode = appMode.DESKTOP
         infra_store.domain_name = "localhost"
-        // expect(viewer_store.base_url).toBe("ws://localhost:1234/ws")
+        // expect(viewerStore.base_url).toBe("ws://localhost:1234/ws")
       })
 
       test("test app_mode CLOUD", () => {
         const infra_store = useInfraStore()
-        const viewer_store = useViewerStore()
+        const viewerStore = useViewerStore()
         infra_store.app_mode = appMode.CLOUD
         infra_store.ID = "123456"
         infra_store.domain_name = "example.com"
-        expect(viewer_store.base_url).toBe(
+        expect(viewerStore.base_url).toBe(
           "wss://example.com:443/123456/viewer/ws",
         )
       })
 
       test("test app_mode CLOUD, ID empty", () => {
         const infra_store = useInfraStore()
-        const viewer_store = useViewerStore()
+        const viewerStore = useViewerStore()
         infra_store.app_mode = appMode.CLOUD
         infra_store.ID = ""
         infra_store.domain_name = "example.com"
-        expect(() => viewer_store.base_url).toThrowError(
+        expect(() => viewerStore.base_url).toThrowError(
           "ID must not be empty in cloud mode",
         )
       })
     })
     describe("is_busy", () => {
       test("test is_busy", () => {
-        const viewer_store = useViewerStore()
-        viewer_store.request_counter = 1
-        expect(viewer_store.is_busy).toBe(true)
+        const viewerStore = useViewerStore()
+        viewerStore.request_counter = 1
+        expect(viewerStore.is_busy).toBe(true)
       })
       test("test not is_busy", () => {
-        const viewer_store = useViewerStore()
-        viewer_store.request_counter = 0
-        expect(viewer_store.is_busy).toBe(false)
+        const viewerStore = useViewerStore()
+        viewerStore.request_counter = 0
+        expect(viewerStore.is_busy).toBe(false)
       })
     })
   })
   describe("actions", () => {
     // test("ws_connect", async () => {
     //   const infra_store = useInfraStore()
-    //   const viewer_store = useViewerStore()
+    //   const viewerStore = useViewerStore()
     //   infra_store.app_mode = appMode.BROWSER
     //   const viewer_path = path.join(
     //     executable_path(
@@ -176,29 +176,31 @@ describe("Viewer Store", () => {
     //     port: 1234,
     //     data_folder_path: "./data",
     //   })
-    //   viewer_store.default_local_port = viewer_port
-    //   await viewer_store.ws_connect()
-    //   expect(viewer_store.status).toBe(Status.CONNECTED)
+    //   viewerStore.default_local_port = viewer_port
+    //   await viewerStore.ws_connect()
+    //   expect(viewerStore.status).toBe(Status.CONNECTED)
     // }, 10000)
     describe("toggle_picking_mode", () => {
       test("test true", async () => {
-        const viewer_store = useViewerStore()
-        await viewer_store.toggle_picking_mode(true)
-        expect(viewer_store.picking_mode).toBe(true)
+        const viewerStore = useViewerStore()
+        await viewerStore.toggle_picking_mode(true)
+        expect(viewerStore.picking_mode).toBe(true)
       })
     })
+
     describe("start_request", () => {
       test("test increment", async () => {
-        const viewer_store = useViewerStore()
-        await viewer_store.start_request()
-        expect(viewer_store.request_counter).toBe(1)
+        const viewerStore = useViewerStore()
+        await viewerStore.start_request()
+        expect(viewerStore.request_counter).toBe(1)
       })
     })
+
     describe("stop_request", () => {
       test("test decrement", async () => {
-        const viewer_store = useViewerStore()
-        await viewer_store.stop_request()
-        expect(viewer_store.request_counter).toBe(-1)
+        const viewerStore = useViewerStore()
+        await viewerStore.stop_request()
+        expect(viewerStore.request_counter).toBe(-1)
       })
     })
   })