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

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

@@ -1,300 +1,300 @@
 // Third party imports
-import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest"
-import { registerEndpoint } from "@nuxt/test-utils/runtime"
+import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest";
+import { registerEndpoint } from "@nuxt/test-utils/runtime";
 
 // Local imports
-import { Status } from "@ogw_front/utils/status"
-import { appMode } from "@ogw_front/utils/local/app_mode"
-import { setupActivePinia } from "@ogw_tests/utils"
-import { useGeodeStore } from "@ogw_front/stores/geode"
-import { useInfraStore } from "@ogw_front/stores/infra"
-import { useLambdaStore } from "@ogw_front/stores/lambda"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { Status } from "@ogw_front/utils/status";
+import { appMode } from "@ogw_front/utils/local/app_mode";
+import { setupActivePinia } from "@ogw_tests/utils";
+import { useGeodeStore } from "@ogw_front/stores/geode";
+import { useInfraStore } from "@ogw_front/stores/infra";
+import { useLambdaStore } from "@ogw_front/stores/lambda";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Mock navigator.locks API
 const mockLockRequest = vi
   .fn()
-  .mockImplementation(async (name, handler) => await handler({ name }))
+  .mockImplementation(async (name, handler) => await handler({ name }));
 
 vi.stubGlobal("navigator", {
   ...navigator,
   locks: {
     request: mockLockRequest,
   },
-})
+});
 
 beforeEach(() => {
-  setupActivePinia()
-})
+  setupActivePinia();
+});
 
 describe("Infra Store", () => {
   describe("state", () => {
     test("initial state", () => {
-      const infraStore = useInfraStore()
-      expectTypeOf(infraStore.ID).toBeString()
-      expectTypeOf(infraStore.is_captcha_validated).toBeBoolean()
-      expectTypeOf(infraStore.status).toBeString()
-    })
-  })
+      const infraStore = useInfraStore();
+      expectTypeOf(infraStore.ID).toBeString();
+      expectTypeOf(infraStore.is_captcha_validated).toBeBoolean();
+      expectTypeOf(infraStore.status).toBeString();
+    });
+  });
   describe("getters", () => {
     describe("app_mode", () => {
       test("test type", () => {
-        const infraStore = useInfraStore()
-        expectTypeOf(infraStore.app_mode).toBeString()
-      })
-    })
+        const infraStore = useInfraStore();
+        expectTypeOf(infraStore.app_mode).toBeString();
+      });
+    });
 
     describe("domain_name", () => {
       test("test app_mode BROWSER", () => {
-        const infraStore = useInfraStore()
-        infraStore.app_mode = appMode.BROWSER
-        expect(infraStore.domain_name).toBe("localhost")
-      })
+        const infraStore = useInfraStore();
+        infraStore.app_mode = appMode.BROWSER;
+        expect(infraStore.domain_name).toBe("localhost");
+      });
       test("test app_mode DESKTOP", () => {
-        const infraStore = useInfraStore()
-        infraStore.app_mode = appMode.DESKTOP
-        expect(infraStore.domain_name).toBe("localhost")
-      })
+        const infraStore = useInfraStore();
+        infraStore.app_mode = appMode.DESKTOP;
+        expect(infraStore.domain_name).toBe("localhost");
+      });
       test("test app_mode CLOUD", () => {
-        const infraStore = useInfraStore()
-        infraStore.app_mode = appMode.CLOUD
-        expect(infraStore.domain_name).toBe("api.geode-solutions.com")
-      })
-    })
+        const infraStore = useInfraStore();
+        infraStore.app_mode = appMode.CLOUD;
+        expect(infraStore.domain_name).toBe("api.geode-solutions.com");
+      });
+    });
 
     describe("microservices_connected", () => {
       test("test no microservices registered", () => {
-        const infraStore = useInfraStore()
-        expect(infraStore.microservices_connected).toBeTruthy()
-      })
+        const infraStore = useInfraStore();
+        expect(infraStore.microservices_connected).toBeTruthy();
+      });
       test("test geode false & viewer false", () => {
-        const infraStore = useInfraStore()
-        const geodeStore = useGeodeStore()
-        const viewerStore = useViewerStore()
+        const infraStore = useInfraStore();
+        const geodeStore = useGeodeStore();
+        const viewerStore = useViewerStore();
 
         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 })
-        expect(infraStore.microservices_connected).toBeFalsy()
-      })
+        geodeStore.$patch({ status: Status.NOT_CONNECTED });
+        viewerStore.$patch({ status: Status.NOT_CONNECTED });
+        expect(infraStore.microservices_connected).toBeFalsy();
+      });
       test("test geode true & viewer false", () => {
-        const infraStore = useInfraStore()
-        const geodeStore = useGeodeStore()
-        const viewerStore = useViewerStore()
+        const infraStore = useInfraStore();
+        const geodeStore = useGeodeStore();
+        const viewerStore = useViewerStore();
 
         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.CONNECTED })
-        viewerStore.$patch({ status: Status.NOT_CONNECTED })
-        expect(infraStore.microservices_connected).toBeFalsy()
-      })
+        geodeStore.$patch({ status: Status.CONNECTED });
+        viewerStore.$patch({ status: Status.NOT_CONNECTED });
+        expect(infraStore.microservices_connected).toBeFalsy();
+      });
       test("test geode false & viewer true", () => {
-        const infraStore = useInfraStore()
-        const geodeStore = useGeodeStore()
-        const viewerStore = useViewerStore()
+        const infraStore = useInfraStore();
+        const geodeStore = useGeodeStore();
+        const viewerStore = useViewerStore();
 
         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.CONNECTED })
-        expect(infraStore.microservices_connected).toBeFalsy()
-      })
+        geodeStore.$patch({ status: Status.NOT_CONNECTED });
+        viewerStore.$patch({ status: Status.CONNECTED });
+        expect(infraStore.microservices_connected).toBeFalsy();
+      });
       test("test geode true & viewer true", () => {
-        const infraStore = useInfraStore()
-        const geodeStore = useGeodeStore()
-        const viewerStore = useViewerStore()
+        const infraStore = useInfraStore();
+        const geodeStore = useGeodeStore();
+        const viewerStore = useViewerStore();
 
         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.CONNECTED })
-        viewerStore.$patch({ status: Status.CONNECTED })
-        expect(infraStore.microservices_connected).toBeTruthy()
-      })
-    })
+        geodeStore.$patch({ status: Status.CONNECTED });
+        viewerStore.$patch({ status: Status.CONNECTED });
+        expect(infraStore.microservices_connected).toBeTruthy();
+      });
+    });
 
     describe("microservices_busy", () => {
       test("test no microservices registered", () => {
-        const infraStore = useInfraStore()
-        expect(infraStore.microservices_busy).toBeFalsy()
-      })
+        const infraStore = useInfraStore();
+        expect(infraStore.microservices_busy).toBeFalsy();
+      });
       test("test geode false & viewer false", () => {
-        const infraStore = useInfraStore()
-        const geodeStore = useGeodeStore()
-        const viewerStore = useViewerStore()
+        const infraStore = useInfraStore();
+        const geodeStore = useGeodeStore();
+        const viewerStore = useViewerStore();
 
         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({ request_counter: 0 })
-        viewerStore.$patch({ request_counter: 0 })
-        expect(infraStore.microservices_busy).toBeFalsy()
-      })
+        geodeStore.$patch({ request_counter: 0 });
+        viewerStore.$patch({ request_counter: 0 });
+        expect(infraStore.microservices_busy).toBeFalsy();
+      });
       test("test geode true & viewer false", () => {
-        const infraStore = useInfraStore()
-        const geodeStore = useGeodeStore()
-        const viewerStore = useViewerStore()
+        const infraStore = useInfraStore();
+        const geodeStore = useGeodeStore();
+        const viewerStore = useViewerStore();
 
         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({ request_counter: 1 })
-        viewerStore.$patch({ request_counter: 0 })
-        expect(infraStore.microservices_busy).toBeTruthy()
-      })
+        geodeStore.$patch({ request_counter: 1 });
+        viewerStore.$patch({ request_counter: 0 });
+        expect(infraStore.microservices_busy).toBeTruthy();
+      });
       test("test geode false & viewer true", () => {
-        const infraStore = useInfraStore()
-        const geodeStore = useGeodeStore()
-        const viewerStore = useViewerStore()
+        const infraStore = useInfraStore();
+        const geodeStore = useGeodeStore();
+        const viewerStore = useViewerStore();
 
         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({ request_counter: 0 })
-        viewerStore.$patch({ request_counter: 1 })
-        expect(infraStore.microservices_busy).toBeTruthy()
-      })
+        geodeStore.$patch({ request_counter: 0 });
+        viewerStore.$patch({ request_counter: 1 });
+        expect(infraStore.microservices_busy).toBeTruthy();
+      });
       test("test geode true & viewer true", () => {
-        const infraStore = useInfraStore()
-        const geodeStore = useGeodeStore()
-        const viewerStore = useViewerStore()
+        const infraStore = useInfraStore();
+        const geodeStore = useGeodeStore();
+        const viewerStore = useViewerStore();
 
         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({ request_counter: 1 })
-        viewerStore.$patch({ request_counter: 1 })
-        expect(infraStore.microservices_busy).toBeTruthy()
-      })
-    })
-  })
+        geodeStore.$patch({ request_counter: 1 });
+        viewerStore.$patch({ request_counter: 1 });
+        expect(infraStore.microservices_busy).toBeTruthy();
+      });
+    });
+  });
 
   describe("actions", () => {
     describe("register_microservice", () => {
       test("register geode microservice", () => {
-        const infraStore = useInfraStore()
-        const geodeStore = useGeodeStore()
+        const infraStore = useInfraStore();
+        const geodeStore = useGeodeStore();
 
         infraStore.register_microservice(geodeStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
-        })
+        });
 
-        expect(infraStore.microservices.length).toBe(1)
-        expect(infraStore.microservices[0].$id).toBe("geode")
-      })
+        expect(infraStore.microservices.length).toBe(1);
+        expect(infraStore.microservices[0].$id).toBe("geode");
+      });
 
       test("register multiple microservices", () => {
-        const infraStore = useInfraStore()
-        const geodeStore = useGeodeStore()
-        const viewerStore = useViewerStore()
+        const infraStore = useInfraStore();
+        const geodeStore = useGeodeStore();
+        const viewerStore = useViewerStore();
 
         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(),
-        })
+        });
 
-        expect(infraStore.microservices.length).toBe(2)
-      })
-    })
+        expect(infraStore.microservices.length).toBe(2);
+      });
+    });
 
     describe("create_backend", () => {
       // Test without microservices
       test("test with end-point", async () => {
-        const infraStore = useInfraStore()
-        const geodeStore = useGeodeStore()
-        const viewerStore = useViewerStore()
-        const lambdaStore = useLambdaStore()
+        const infraStore = useInfraStore();
+        const geodeStore = useGeodeStore();
+        const viewerStore = useViewerStore();
+        const lambdaStore = useLambdaStore();
 
-        infraStore.app_mode = appMode.CLOUD
-        const ID = "123456"
+        infraStore.app_mode = appMode.CLOUD;
+        const ID = "123456";
         registerEndpoint(lambdaStore.base_url, {
           method: "POST",
           handler: () => ({ ID }),
-        })
-        await infraStore.create_backend()
-        expect(infraStore.status).toBe(Status.CREATED)
-        expect(infraStore.ID).toBe(ID)
-
-        expect(geodeStore.status).toBe(Status.NOT_CONNECTED)
-        expect(viewerStore.status).toBe(Status.NOT_CONNECTED)
-      })
-    })
-  })
-})
+        });
+        await infraStore.create_backend();
+        expect(infraStore.status).toBe(Status.CREATED);
+        expect(infraStore.ID).toBe(ID);
+
+        expect(geodeStore.status).toBe(Status.NOT_CONNECTED);
+        expect(viewerStore.status).toBe(Status.NOT_CONNECTED);
+      });
+    });
+  });
+});

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

@@ -1,132 +1,130 @@
 // Third party imports
-import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest"
-import { registerEndpoint } from "@nuxt/test-utils/runtime"
+import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest";
+import { registerEndpoint } from "@nuxt/test-utils/runtime";
 
 // Local imports
-import { Status } from "@ogw_front/utils/status"
-import { setupActivePinia } from "@ogw_tests/utils"
-import { useFeedbackStore } from "@ogw_front/stores/feedback"
-import { useLambdaStore } from "@ogw_front/stores/lambda"
+import { Status } from "@ogw_front/utils/status";
+import { setupActivePinia } from "@ogw_tests/utils";
+import { useFeedbackStore } from "@ogw_front/stores/feedback";
+import { useLambdaStore } from "@ogw_front/stores/lambda";
 
 // CONSTANTS
-const PORT_443 = "443"
-const API_URL = "api.example.com"
-const SITE_BRANCH = "/test"
-const PROJECT = "project"
-const TEST_ID = "test-id-123456"
-const STATUS_500 = 500
+const PORT_443 = "443";
+const API_URL = "api.example.com";
+const SITE_BRANCH = "/test";
+const PROJECT = "project";
+const TEST_ID = "test-id-123456";
+const STATUS_500 = 500;
 
-beforeEach(async () => {
-  setupActivePinia()
-})
+beforeEach(() => {
+  setupActivePinia();
+});
 
 function setupConfig() {
-  const config = useRuntimeConfig()
-  config.public.API_URL = API_URL
-  config.public.SITE_BRANCH = SITE_BRANCH
-  config.public.PROJECT = PROJECT
+  const config = useRuntimeConfig();
+  config.public.API_URL = API_URL;
+  config.public.SITE_BRANCH = SITE_BRANCH;
+  config.public.PROJECT = PROJECT;
 }
 
 describe("Lambda Store", () => {
   describe("state", () => {
     test("initial state", () => {
-      const lambdaStore = useLambdaStore()
-      expectTypeOf(lambdaStore.status).toBeString()
-      expect(lambdaStore.status).toBe(Status.NOT_CONNECTED)
-    })
-  })
+      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")
-      })
-    })
+        const lambdaStore = useLambdaStore();
+        expect(lambdaStore.protocol).toBe("https");
+      });
+    });
 
     describe("port", () => {
       test("test port is always 443", () => {
-        const lambdaStore = useLambdaStore()
-        expect(lambdaStore.port).toBe(PORT_443)
-      })
-    })
+        const lambdaStore = useLambdaStore();
+        expect(lambdaStore.port).toBe(PORT_443);
+      });
+    });
 
     describe("base_url", () => {
       test("test base_url construction", () => {
-        setupConfig()
-        const lambdaStore = useLambdaStore()
+        setupConfig();
+        const lambdaStore = useLambdaStore();
         expect(lambdaStore.base_url).toBe(
           `https://${API_URL}:${PORT_443}${SITE_BRANCH}/${PROJECT}/createbackend`,
-        )
-      })
-    })
+        );
+      });
+    });
 
     describe("is_busy", () => {
       test("test is_busy is always false", () => {
-        const lambdaStore = useLambdaStore()
-        expect(lambdaStore.is_busy).toBeFalsy()
-      })
-    })
-  })
+        const lambdaStore = useLambdaStore();
+        expect(lambdaStore.is_busy).toBeFalsy();
+      });
+    });
+  });
 
   describe("actions", () => {
     describe("launch", () => {
-      const postFakeCall = vi.fn()
+      const postFakeCall = vi.fn();
 
       test("successful launch", async () => {
-        setupConfig()
-        const lambdaStore = useLambdaStore()
-        const feedbackStore = useFeedbackStore()
+        setupConfig();
+        const lambdaStore = useLambdaStore();
+        const feedbackStore = useFeedbackStore();
 
-        lambdaStore.base_url = "test-base-url"
+        lambdaStore.base_url = "test-base-url";
         registerEndpoint(lambdaStore.base_url, {
           method: "POST",
           handler: postFakeCall,
-        })
+        });
 
         postFakeCall.mockImplementation(() => ({
           ID: TEST_ID,
-        }))
+        }));
 
-        const id = await lambdaStore.launch()
+        const id = await lambdaStore.launch();
 
-        expect(lambdaStore.status).toBe(Status.CONNECTED)
-        expect(id).toBe(TEST_ID)
-        expect(feedbackStore.server_error).toBeFalsy()
-      })
+        expect(lambdaStore.status).toBe(Status.CONNECTED);
+        expect(id).toBe(TEST_ID);
+        expect(feedbackStore.server_error).toBeFalsy();
+      });
 
       test("failed launch - error response", async () => {
-        setupConfig()
-        const lambdaStore = useLambdaStore()
-        const feedbackStore = useFeedbackStore()
+        setupConfig();
+        const lambdaStore = useLambdaStore();
+        const feedbackStore = useFeedbackStore();
 
         registerEndpoint(lambdaStore.base_url, {
           method: "POST",
           handler: postFakeCall,
-        })
+        });
 
         postFakeCall.mockImplementation(() => {
           throw createError({
             status: STATUS_500,
             statusMessage: "Internal Server Error",
-          })
-        })
+          });
+        });
 
-        await expect(lambdaStore.launch()).rejects.toThrow(
-          "Failed to launch lambda backend",
-        )
+        await expect(lambdaStore.launch()).rejects.toThrow("Failed to launch lambda backend");
 
-        expect(lambdaStore.status).toBe(Status.NOT_CONNECTED)
-        expect(feedbackStore.server_error).toBeTruthy()
-      })
-    })
+        expect(lambdaStore.status).toBe(Status.NOT_CONNECTED);
+        expect(feedbackStore.server_error).toBeTruthy();
+      });
+    });
 
     describe("connect", () => {
       test("successful connect", async () => {
-        const lambdaStore = useLambdaStore()
-        await lambdaStore.connect()
-        expect(lambdaStore.status).toBe(Status.CONNECTED)
-      })
-    })
-  })
-})
+        const lambdaStore = useLambdaStore();
+        await lambdaStore.connect();
+        expect(lambdaStore.status).toBe(Status.CONNECTED);
+      });
+    });
+  });
+});