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

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

@@ -1,47 +1,45 @@
 // Third party imports
-import { beforeEach, describe, expect, test } from "vitest"
-import { registerEndpoint } from "@nuxt/test-utils/runtime"
-import schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+import { beforeEach, describe, expect, test } from "vitest";
+import { registerEndpoint } from "@nuxt/test-utils/runtime";
+import schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json";
 
 // 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 ZERO = 0
-const schema = schemas.opengeodeweb_back.upload_file
+const ZERO = 0;
+const schema = schemas.opengeodeweb_back.upload_file;
 
 beforeEach(() => {
-  setupActivePinia()
-  const geodeStore = useGeodeStore()
-  geodeStore.base_url = ""
-})
+  setupActivePinia();
+  const geodeStore = useGeodeStore();
+  geodeStore.base_url = "";
+});
 
 describe("upload_file test", () => {
   test("throw error", async () => {
-    const geodeStore = useGeodeStore()
-    const file = "toto"
+    const geodeStore = useGeodeStore();
+    const file = "toto";
 
-    await expect(geodeStore.upload(file)).rejects.toThrow(
-      "file must be a instance of File",
-    )
-  })
+    await expect(geodeStore.upload(file)).rejects.toThrow("file must be a instance of File");
+  });
 
   test("onResponse", async () => {
-    const feedbackStore = useFeedbackStore()
-    const geodeStore = useGeodeStore()
+    const feedbackStore = useFeedbackStore();
+    const geodeStore = useGeodeStore();
     registerEndpoint(schema.$id, {
       method: "PUT",
       handler: () => ({ test: "ok" }),
-    })
-    const file = new File(["fake_file"], "fake_file.txt")
-    let response_value = ""
+    });
+    const file = new File(["fake_file"], "fake_file.txt");
+    let response_value = "";
     await geodeStore.upload(file, {
       response_function: (response) => {
-        response_value = response._data.test
+        response_value = response._data.test;
       },
-    })
-    expect(feedbackStore.feedbacks).toHaveLength(ZERO)
-    expect(response_value).toBe("ok")
-  })
-})
+    });
+    expect(feedbackStore.feedbacks).toHaveLength(ZERO);
+    expect(response_value).toBe("ok");
+  });
+});

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

@@ -1,23 +1,23 @@
-import { beforeEach, describe, expect, test, vi } from "vitest"
+import { beforeEach, describe, expect, test, vi } from "vitest";
 
-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 { 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 { useTreeviewStore } from "@ogw_front/stores/treeview";
 
-import { database } from "@ogw_internal/database/database.js"
-import { setupActivePinia } from "@ogw_tests/utils"
+import { database } from "@ogw_internal/database/database.js";
+import { setupActivePinia } from "@ogw_tests/utils";
 
-const PANEL_WIDTH = 320
-const Z_SCALE = 1.5
-const STORES_SLICE_START = 1
+const PANEL_WIDTH = 320;
+const Z_SCALE = 1.5;
+const STORES_SLICE_START = 1;
 
 vi.mock(import("@ogw_internal/utils/viewer_call"), () => ({
   viewer_call: vi.fn(async () => {
-    await Promise.resolve()
+    await Promise.resolve();
   }),
-}))
+}));
 vi.mock(import("@ogw_front/stores/hybrid_viewer"), () => ({
   useHybridViewerStore: () => ({
     $id: "hybridViewer",
@@ -28,11 +28,11 @@ vi.mock(import("@ogw_front/stores/hybrid_viewer"), () => ({
     save: vi.fn(),
     load: vi.fn(),
   }),
-}))
+}));
 
 beforeEach(() => {
-  setupActivePinia()
-})
+  setupActivePinia();
+});
 
 describe("Project import", () => {
   test("app.importStores restores stores", async () => {
@@ -42,18 +42,16 @@ describe("Project import", () => {
       treeview: useTreeviewStore(),
       dataStyle: useDataStyleStore(),
       hybrid: useHybridViewerStore(),
-    }
-    const storesArray = Object.values(stores)
+    };
+    const storesArray = Object.values(stores);
     for (const store of storesArray.slice(STORES_SLICE_START)) {
-      stores.app.registerStore(store)
+      stores.app.registerStore(store);
     }
 
-    vi.spyOn(stores.dataBase, "importStores").mockImplementation(
-      async (snapshot) => {
-        const items = snapshot?.items || []
-        await Promise.all(items.map((item) => database.data.put(item)))
-      },
-    )
+    vi.spyOn(stores.dataBase, "importStores").mockImplementation(async (snapshot) => {
+      const items = snapshot?.items || [];
+      await Promise.all(items.map((item) => database.data.put(item)));
+    });
 
     const snapshot = {
       data: {
@@ -81,13 +79,13 @@ describe("Project import", () => {
       },
       dataStyle: { styles: { abc123: { some: "style" } } },
       hybridViewer: { zScale: Z_SCALE },
-    }
+    };
 
-    await stores.app.importStores(snapshot)
+    await stores.app.importStores(snapshot);
 
-    const item = await database.data.get("abc123")
-    expect(item).toBeDefined()
-    expect(item.id).toBe("abc123")
-    expect(stores.dataStyle.styles.abc123).toBeDefined()
-  })
-})
+    const item = await database.data.get("abc123");
+    expect(item).toBeDefined();
+    expect(item.id).toBe("abc123");
+    expect(stores.dataStyle.styles.abc123).toBeDefined();
+  });
+});

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

@@ -1,71 +1,71 @@
-import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest"
+import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest";
 
-import { useAppStore } from "@ogw_front/stores/app"
+import { useAppStore } from "@ogw_front/stores/app";
 
-import { setupActivePinia } from "@ogw_tests/utils"
+import { setupActivePinia } from "@ogw_tests/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
+const SINGLE_STORE_LENGTH = 1;
+const MULTIPLE_STORES_LENGTH = 2;
+const FIRST_INDEX = 0;
+const SECOND_INDEX = 1;
+const CALL_COUNT_ONCE = 1;
 
 beforeEach(() => {
-  setupActivePinia()
-})
+  setupActivePinia();
+});
 describe("app store", () => {
   describe("state", () => {
     test("initial state", () => {
-      const appStore = useAppStore()
-      expectTypeOf(appStore.stores).toBeArray()
-      expectTypeOf(appStore.exportStores).toBeFunction()
-      expectTypeOf(appStore.importStores).toBeFunction()
-      expectTypeOf(appStore.registerStore).toBeFunction()
-    })
-  })
+      const appStore = useAppStore();
+      expectTypeOf(appStore.stores).toBeArray();
+      expectTypeOf(appStore.exportStores).toBeFunction();
+      expectTypeOf(appStore.importStores).toBeFunction();
+      expectTypeOf(appStore.registerStore).toBeFunction();
+    });
+  });
 
   describe("actions", () => {
     describe("registerStore", () => {
       test("register single store", () => {
-        const appStore = useAppStore()
+        const appStore = useAppStore();
         const mock_store = {
           $id: "testStore",
           save: vi.fn().mockImplementation(() => ({ data: "test" })),
           load: vi.fn().mockImplementation(),
-        }
+        };
 
-        appStore.registerStore(mock_store)
+        appStore.registerStore(mock_store);
 
-        expect(appStore.stores).toHaveLength(SINGLE_STORE_LENGTH)
-        expect(appStore.stores[FIRST_INDEX]).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 appStore = useAppStore();
         const mock_store_1 = {
           $id: "userStore",
           save: vi.fn().mockImplementation(),
           load: vi.fn().mockImplementation(),
-        }
+        };
         const mock_store_2 = {
           $id: "geodeStore",
           save: vi.fn().mockImplementation(),
           load: vi.fn().mockImplementation(),
-        }
+        };
 
-        appStore.registerStore(mock_store_1)
-        appStore.registerStore(mock_store_2)
+        appStore.registerStore(mock_store_1);
+        appStore.registerStore(mock_store_2);
 
-        expect(appStore.stores).toHaveLength(MULTIPLE_STORES_LENGTH)
-        expect(appStore.stores[FIRST_INDEX].$id).toBe("userStore")
-        expect(appStore.stores[SECOND_INDEX].$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", () => {
       test("export stores with exportStores method", async () => {
-        const appStore = useAppStore()
+        const appStore = useAppStore();
         const mock_store_1 = {
           $id: "userStore",
           exportStores: vi.fn().mockImplementation(() => ({
@@ -73,117 +73,115 @@ describe("app store", () => {
             email: "toto@titi.com",
           })),
           importStores: vi.fn().mockImplementation(),
-        }
+        };
         const mock_store_2 = {
           $id: "geodeStore",
-          exportStores: vi
-            .fn()
-            .mockImplementation(() => ({ items: [], total: 0 })),
+          exportStores: vi.fn().mockImplementation(() => ({ items: [], total: 0 })),
           importStores: vi.fn().mockImplementation(),
-        }
+        };
 
-        appStore.registerStore(mock_store_1)
-        appStore.registerStore(mock_store_2)
+        appStore.registerStore(mock_store_1);
+        appStore.registerStore(mock_store_2);
 
-        const snapshot = await appStore.exportStores()
+        const snapshot = await appStore.exportStores();
 
-        expect(mock_store_1.exportStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE)
-        expect(mock_store_2.exportStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE)
+        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 },
-        })
-      })
+        });
+      });
 
       test("skip stores without exportSave method", async () => {
-        const appStore = useAppStore()
+        const appStore = useAppStore();
         const mock_store_1 = {
           $id: "withSave",
           exportStores: vi.fn().mockImplementation(() => ({ data: "test" })),
           importStores: vi.fn().mockImplementation(),
-        }
+        };
         const mock_store_2 = {
           $id: "withoutSave",
           importStores: vi.fn().mockImplementation(),
-        }
+        };
 
-        appStore.registerStore(mock_store_1)
-        appStore.registerStore(mock_store_2)
+        appStore.registerStore(mock_store_1);
+        appStore.registerStore(mock_store_2);
 
-        const snapshot = await appStore.exportStores()
+        const snapshot = await appStore.exportStores();
 
-        expect(mock_store_1.exportStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE)
+        expect(mock_store_1.exportStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE);
         expect(snapshot).toEqual({
           withSave: { data: "test" },
-        })
-        expect(snapshot.withoutSave).toBeUndefined()
-      })
+        });
+        expect(snapshot.withoutSave).toBeUndefined();
+      });
 
       test("return empty snapshot when no stores registered", async () => {
-        const appStore = useAppStore()
-        const snapshot = await appStore.exportStores()
-        expect(snapshot).toStrictEqual({})
-      })
-    })
+        const appStore = useAppStore();
+        const snapshot = await appStore.exportStores();
+        expect(snapshot).toStrictEqual({});
+      });
+    });
 
     describe("load", () => {
       test("import stores with importStores method", async () => {
-        const appStore = useAppStore()
+        const appStore = useAppStore();
         const userStore = {
           $id: "userStore",
           importStores: vi.fn().mockResolvedValue(),
-        }
+        };
         const geodeStore = {
           $id: "geodeStore",
           importStores: vi.fn().mockResolvedValue(),
-        }
-        appStore.registerStore(userStore)
-        appStore.registerStore(geodeStore)
+        };
+        appStore.registerStore(userStore);
+        appStore.registerStore(geodeStore);
         const snapshot = {
           userStore: { some: "data" },
           geodeStore: { other: "data" },
-        }
-        await appStore.importStores(snapshot)
-        expect(userStore.importStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE)
-        expect(geodeStore.importStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE)
-      })
+        };
+        await appStore.importStores(snapshot);
+        expect(userStore.importStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE);
+        expect(geodeStore.importStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE);
+      });
 
       test("skip stores without importStores method", async () => {
-        const appStore = useAppStore()
+        const appStore = useAppStore();
         const mock_store_1 = {
           $id: "withImport",
           save: vi.fn().mockImplementation(),
           importStores: vi.fn().mockImplementation(),
-        }
+        };
         const mock_store_2 = {
           $id: "withoutImport",
           save: vi.fn().mockImplementation(),
-        }
-        appStore.registerStore(mock_store_1)
-        appStore.registerStore(mock_store_2)
+        };
+        appStore.registerStore(mock_store_1);
+        appStore.registerStore(mock_store_2);
         const snapshot = {
           withImport: { data: "test" },
           withoutImport: { data: "ignored" },
-        }
-        await appStore.importStores(snapshot)
-        expect(mock_store_1.importStores).toHaveBeenCalledTimes(CALL_COUNT_ONCE)
-        expect(mock_store_2.importStores).toBeUndefined()
-      })
+        };
+        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", async () => {
-        const appStore = useAppStore()
-        const console_warn_spy = vi.spyOn(console, "warn").mockImplementation()
+        const appStore = useAppStore();
+        const console_warn_spy = vi.spyOn(console, "warn").mockImplementation();
         const mock_store = {
           $id: "testStore",
           importStores: vi.fn().mockImplementation(),
-        }
-        appStore.registerStore(mock_store)
-        await appStore.importStores({})
+        };
+        appStore.registerStore(mock_store);
+        await appStore.importStores({});
         expect(console_warn_spy).toHaveBeenCalledWith(
           expect.stringContaining("Stores not found in snapshot: testStore"),
-        )
-        console_warn_spy.mockRestore()
-      })
-    })
-  })
-})
+        );
+        console_warn_spy.mockRestore();
+      });
+    });
+  });
+});

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

@@ -1,85 +1,75 @@
 // Third party imports
-import { beforeEach, describe, expect, expectTypeOf, test } from "vitest"
+import { beforeEach, describe, expect, expectTypeOf, test } from "vitest";
 
 // Local imports
-import { setupActivePinia } from "@ogw_tests/utils"
-import { useFeedbackStore } from "@ogw_front/stores/feedback"
+import { setupActivePinia } from "@ogw_tests/utils";
+import { useFeedbackStore } from "@ogw_front/stores/feedback";
 
-const ERROR_500 = 500
-const MILISECONDS_TIMEOUT = 1000
+const ERROR_500 = 500;
+const MILISECONDS_TIMEOUT = 1000;
 
 beforeEach(() => {
-  setupActivePinia()
-})
+  setupActivePinia();
+});
 
 describe("Feedback Store", () => {
   describe("state", () => {
     test("initial state", () => {
-      const feedbackStore = useFeedbackStore()
-      expectTypeOf(feedbackStore.feedbacks).toEqualTypeOf([])
-      expectTypeOf(feedbackStore.server_error).toBeBoolean()
-    })
-  })
+      const feedbackStore = useFeedbackStore();
+      expectTypeOf(feedbackStore.feedbacks).toEqualTypeOf([]);
+      expectTypeOf(feedbackStore.server_error).toBeBoolean();
+    });
+  });
 
   describe("actions", () => {
     describe("add_error", () => {
       test("test add_error", () => {
-        const feedbackStore = useFeedbackStore()
-        feedbackStore.add_error(
-          ERROR_500,
-          "/test",
-          "test message",
-          "test description",
-        )
-        expect(feedbackStore.feedbacks).toHaveLength(1)
-        expect(feedbackStore.feedbacks[0].type).toBe("error")
-      })
+        const feedbackStore = useFeedbackStore();
+        feedbackStore.add_error(ERROR_500, "/test", "test message", "test description");
+        expect(feedbackStore.feedbacks).toHaveLength(1);
+        expect(feedbackStore.feedbacks[0].type).toBe("error");
+      });
 
       test("test feedbacks_timeout", () => {
-        const feedbackStore = useFeedbackStore()
-        feedbackStore.feedbacks_timeout_miliseconds = 500
-        feedbackStore.add_error(
-          ERROR_500,
-          "/test",
-          "test message",
-          "test description",
-        )
-        expect(feedbackStore.feedbacks).toHaveLength(1)
+        const feedbackStore = useFeedbackStore();
+        feedbackStore.feedbacks_timeout_miliseconds = 500;
+        feedbackStore.add_error(ERROR_500, "/test", "test message", "test description");
+        expect(feedbackStore.feedbacks).toHaveLength(1);
         setTimeout(() => {
-          expect(feedbackStore.feedbacks).toHaveLength(0)
-        }, MILISECONDS_TIMEOUT)
-      })
-    })
+          expect(feedbackStore.feedbacks).toHaveLength(0);
+        }, MILISECONDS_TIMEOUT);
+      });
+    });
 
     describe("add_success", () => {
       test("test add_success", () => {
-        const feedbackStore = useFeedbackStore()
-        feedbackStore.feedbacks_timeout_miliseconds = 500
-        feedbackStore.add_success("test description")
-        expect(feedbackStore.feedbacks).toHaveLength(1)
-        expect(feedbackStore.feedbacks[0].type).toBe("success")
+        const feedbackStore = useFeedbackStore();
+        feedbackStore.feedbacks_timeout_miliseconds = 500;
+        feedbackStore.add_success("test description");
+        expect(feedbackStore.feedbacks).toHaveLength(1);
+        expect(feedbackStore.feedbacks[0].type).toBe("success");
 
         setTimeout(() => {
-          expect(feedbackStore.feedbacks).toHaveLength(0)
-        }, MILISECONDS_TIMEOUT)
-      })
-    })
+          expect(feedbackStore.feedbacks).toHaveLength(0);
+        }, MILISECONDS_TIMEOUT);
+      });
+    });
 
     describe("delete_feedback", () => {
       test("test", () => {
-        const feedbackStore = useFeedbackStore()
-        feedbackStore.delete_feedback(0)
-        expect(feedbackStore.feedbacks).toHaveLength(0)
-      })
-    })
+        const feedbackStore = useFeedbackStore();
+        feedbackStore.delete_feedback(0);
+        expect(feedbackStore.feedbacks).toHaveLength(0);
+      });
+    });
 
     describe("delete_server_error", () => {
       test("test", () => {
-        const feedbackStore = useFeedbackStore()
-        feedbackStore.$patch({ server_error: true })
-        feedbackStore.delete_server_error()
-        expect(feedbackStore.server_error).toBeFalsy()
-      })
-    })
-  })
-})
+        const feedbackStore = useFeedbackStore();
+        feedbackStore.$patch({ server_error: true });
+        feedbackStore.delete_server_error();
+        expect(feedbackStore.server_error).toBeFalsy();
+      });
+    });
+  });
+});