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

package/tests/integration/stores/data_style/model/lines.nuxt.test.js

@@ -1,108 +1,95 @@
 // Third party imports
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" };
 
 // Local imports
-import { Status } from "@ogw_front/utils/status"
-import { cleanupBackend } from "@ogw_front/utils/local/cleanup"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
-import { useDataStore } from "@ogw_front/stores/data"
-import { useDataStyleStore } from "@ogw_front/stores/data_style"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { Status } from "@ogw_front/utils/status";
+import { cleanupBackend } from "@ogw_front/utils/local/cleanup";
+import { setupIntegrationTests } from "@ogw_tests/integration/setup";
+import { useDataStore } from "@ogw_front/stores/data";
+import { useDataStyleStore } from "@ogw_front/stores/data_style";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const INTERVAL_TIMEOUT = 20_000
-const model_lines_schemas = viewer_schemas.opengeodeweb_viewer.model.lines
-const file_name = "test.og_brep"
-const geode_object = "BRep"
+const INTERVAL_TIMEOUT = 20_000;
+const model_lines_schemas = viewer_schemas.opengeodeweb_viewer.model.lines;
+const file_name = "test.og_brep";
+const geode_object = "BRep";
 
 let id = "",
-  projectFolderPath = ""
+  projectFolderPath = "";
 
 beforeEach(async () => {
-  ;({ id, projectFolderPath } = await setupIntegrationTests(
-    file_name,
-    geode_object,
-  ))
-}, INTERVAL_TIMEOUT)
+  ({ id, projectFolderPath } = await setupIntegrationTests(file_name, geode_object));
+}, INTERVAL_TIMEOUT);
 afterEach(async () => {
-  console.log("afterEach model lines kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach model lines kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 
 describe("Model lines", () => {
   describe("Lines visibility", () => {
     test("Visibility false", async () => {
-      console.log("FROM TEST MODEL LINES")
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const dataStore = useDataStore()
-      const line_ids = await dataStore.getLinesGeodeIds(id)
-      const lines_viewer_ids = await dataStore.getMeshComponentsViewerIds(
-        id,
-        line_ids,
-      )
-      const visibility = false
-      const spy = vi.spyOn(viewerStore, "request")
-      spy.mockClear()
-      const result = dataStyleStore.setModelLinesVisibility(
-        id,
-        line_ids,
-        visibility,
-      )
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      console.log("FROM TEST MODEL LINES");
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const line_ids = await dataStore.getLinesGeodeIds(id);
+      const lines_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, line_ids);
+      const visibility = false;
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelLinesVisibility(id, line_ids, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         model_lines_schemas.visibility,
         { id, block_ids: lines_viewer_ids, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
+      );
       for (const line_id of line_ids) {
-        expect(dataStyleStore.modelLineVisibility(id, line_id)).toBe(visibility)
+        expect(dataStyleStore.modelLineVisibility(id, line_id)).toBe(visibility);
       }
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Lines color", () => {
     test("Color red", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const dataStore = useDataStore()
-      const line_ids = await dataStore.getLinesGeodeIds(id)
-      const lines_viewer_ids = await dataStore.getMeshComponentsViewerIds(
-        id,
-        line_ids,
-      )
-      const color = { r: 255, g: 0, b: 0 }
-      const spy = vi.spyOn(viewerStore, "request")
-      spy.mockClear()
-      const result = dataStyleStore.setModelLinesColor(id, line_ids, color)
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const line_ids = await dataStore.getLinesGeodeIds(id);
+      const lines_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, line_ids);
+      const color = { r: 255, g: 0, b: 0 };
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelLinesColor(id, line_ids, color);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         model_lines_schemas.color,
         { id, block_ids: lines_viewer_ids, color },
         {
           response_function: expect.any(Function),
         },
-      )
+      );
       for (const line_id of line_ids) {
-        expect(dataStyleStore.modelLineColor(id, line_id)).toStrictEqual(color)
+        expect(dataStyleStore.modelLineColor(id, line_id)).toStrictEqual(color);
       }
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
   describe("Lines style", () => {
     test("Lines apply style", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const result = dataStyleStore.applyModelLinesStyle(id)
-      expect(result).toBeInstanceOf(Promise)
-      await result
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
-})
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const result = dataStyleStore.applyModelLinesStyle(id);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+});

package/tests/integration/stores/data_style/model/points.nuxt.test.js

@@ -1,87 +1,84 @@
 // Third party imports
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" };
 
 // Local imports
-import { Status } from "@ogw_front/utils/status"
-import { cleanupBackend } from "@ogw_front/utils/local/cleanup"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
-import { useDataStyleStore } from "@ogw_front/stores/data_style"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { Status } from "@ogw_front/utils/status";
+import { cleanupBackend } from "@ogw_front/utils/local/cleanup";
+import { setupIntegrationTests } from "@ogw_tests/integration/setup";
+import { useDataStyleStore } from "@ogw_front/stores/data_style";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const INTERVAL_TIMEOUT = 20_000
-const model_points_schemas = viewer_schemas.opengeodeweb_viewer.model.points
-const file_name = "test.og_brep"
-const geode_object = "BRep"
+const INTERVAL_TIMEOUT = 20_000;
+const model_points_schemas = viewer_schemas.opengeodeweb_viewer.model.points;
+const file_name = "test.og_brep";
+const geode_object = "BRep";
 
 let id = "",
-  projectFolderPath = ""
+  projectFolderPath = "";
 
 beforeEach(async () => {
-  ;({ id, projectFolderPath } = await setupIntegrationTests(
-    file_name,
-    geode_object,
-  ))
-}, INTERVAL_TIMEOUT)
+  ({ id, projectFolderPath } = await setupIntegrationTests(file_name, geode_object));
+}, INTERVAL_TIMEOUT);
 
 afterEach(async () => {
-  console.log("afterEach model points kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach model points kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 
 describe("Model points", () => {
   describe("Points visibility", () => {
     test("Visibility true", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const visibility = true
-      const spy = vi.spyOn(viewerStore, "request")
-      spy.mockClear()
-      const result = dataStyleStore.setModelPointsVisibility(id, visibility)
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const visibility = true;
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelPointsVisibility(id, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         model_points_schemas.visibility,
         { id, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.modelPointsVisibility(id)).toBe(visibility)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.modelPointsVisibility(id)).toBe(visibility);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Points size", () => {
     test("Size 20", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const size = 20
-      const spy = vi.spyOn(viewerStore, "request")
-      spy.mockClear()
-      const result = dataStyleStore.setModelPointsSize(id, size)
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const size = 20;
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelPointsSize(id, size);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         model_points_schemas.size,
         { id, size },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.modelPointsSize(id)).toBe(size)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.modelPointsSize(id)).toBe(size);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
   describe("Points style", () => {
     test("Points apply style", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const result = dataStyleStore.applyModelPointsStyle(id)
-      expect(result).toBeInstanceOf(Promise)
-      await result
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
-})
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const result = dataStyleStore.applyModelPointsStyle(id);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+});

package/tests/integration/stores/data_style/model/surfaces.nuxt.test.js

@@ -1,115 +1,94 @@
 // Third party imports
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" };
 
 // Local imports
-import { Status } from "@ogw_front/utils/status"
-import { cleanupBackend } from "@ogw_front/utils/local/cleanup"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
-import { useDataStore } from "@ogw_front/stores/data"
-import { useDataStyleStore } from "@ogw_front/stores/data_style"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { Status } from "@ogw_front/utils/status";
+import { cleanupBackend } from "@ogw_front/utils/local/cleanup";
+import { setupIntegrationTests } from "@ogw_tests/integration/setup";
+import { useDataStore } from "@ogw_front/stores/data";
+import { useDataStyleStore } from "@ogw_front/stores/data_style";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const INTERVAL_TIMEOUT = 20_000
-const model_surfaces_schemas = viewer_schemas.opengeodeweb_viewer.model.surfaces
-const file_name = "test.og_brep"
-const geode_object = "BRep"
+const INTERVAL_TIMEOUT = 20_000;
+const model_surfaces_schemas = viewer_schemas.opengeodeweb_viewer.model.surfaces;
+const file_name = "test.og_brep";
+const geode_object = "BRep";
 
 let id = "",
-  projectFolderPath = ""
+  projectFolderPath = "";
 
 beforeEach(async () => {
-  ;({ id, projectFolderPath } = await setupIntegrationTests(
-    file_name,
-    geode_object,
-  ))
-}, INTERVAL_TIMEOUT)
+  ({ id, projectFolderPath } = await setupIntegrationTests(file_name, geode_object));
+}, INTERVAL_TIMEOUT);
 
 afterEach(async () => {
-  console.log("afterEach model surfaces kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach model surfaces kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 describe("model surfaces", () => {
   describe("surfaces visibility", () => {
     test("visibility true", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const dataStore = useDataStore()
-      const surface_ids = await dataStore.getSurfacesGeodeIds(id)
-      const surface_viewer_ids = await dataStore.getMeshComponentsViewerIds(
-        id,
-        surface_ids,
-      )
-      const visibility = true
-      const spy = vi.spyOn(viewerStore, "request")
-      spy.mockClear() // Clear calls from setup (applyDefaultStyle)
-      const result = dataStyleStore.setModelSurfacesVisibility(
-        id,
-        surface_ids,
-        visibility,
-      )
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const surface_ids = await dataStore.getSurfacesGeodeIds(id);
+      const surface_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, surface_ids);
+      const visibility = true;
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelSurfacesVisibility(id, surface_ids, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         model_surfaces_schemas.visibility,
         { id, block_ids: surface_viewer_ids, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
+      );
       for (const surface_id of surface_ids) {
-        expect(dataStyleStore.modelSurfaceVisibility(id, surface_id)).toBe(
-          visibility,
-        )
+        expect(dataStyleStore.modelSurfaceVisibility(id, surface_id)).toBe(visibility);
       }
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("surfaces color", () => {
     test("color red", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const dataStore = useDataStore()
-      const surface_ids = await dataStore.getSurfacesGeodeIds(id)
-      const surface_viewer_ids = await dataStore.getMeshComponentsViewerIds(
-        id,
-        surface_ids,
-      )
-      const color = { r: 255, g: 0, b: 0 }
-      const spy = vi.spyOn(viewerStore, "request")
-      spy.mockClear() // Clear calls from setup (applyDefaultStyle)
-      const result = dataStyleStore.setModelSurfacesColor(
-        id,
-        surface_ids,
-        color,
-      )
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const surface_ids = await dataStore.getSurfacesGeodeIds(id);
+      const surface_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, surface_ids);
+      const color = { r: 255, g: 0, b: 0 };
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelSurfacesColor(id, surface_ids, color);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         model_surfaces_schemas.color,
         { id, block_ids: surface_viewer_ids, color },
         {
           response_function: expect.any(Function),
         },
-      )
+      );
       for (const surface_id of surface_ids) {
-        expect(dataStyleStore.modelSurfaceColor(id, surface_id)).toStrictEqual(
-          color,
-        )
+        expect(dataStyleStore.modelSurfaceColor(id, surface_id)).toStrictEqual(color);
       }
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
   describe("Surfaces style", () => {
     test("Surfaces apply style", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const result = dataStyleStore.applyModelSurfacesStyle(id)
-      expect(result).toBeInstanceOf(Promise)
-      await result
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
-})
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const result = dataStyleStore.applyModelSurfacesStyle(id);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+});

package/tests/integration/stores/viewer.nuxt.test.js

@@ -1,28 +1,28 @@
 // Global imports
 
 // Third party imports
-import { afterEach, beforeEach, describe, expect, test } from "vitest"
-import opengeodeweb_viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import opengeodeweb_viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 // Local imports
-import { Status } from "@ogw_front/utils/status"
-import { cleanupBackend } from "@ogw_front/utils/local/cleanup"
-import { runMicroservices } from "@ogw_tests/integration/setup"
-import { setupActivePinia } from "@ogw_tests/utils"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { Status } from "@ogw_front/utils/status";
+import { cleanupBackend } from "@ogw_front/utils/local/cleanup";
+import { runMicroservices } from "@ogw_tests/integration/setup";
+import { setupActivePinia } from "@ogw_tests/utils";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
-const CONNECT_TIMEOUT = 25_000
+const CONNECT_TIMEOUT = 25_000;
 
-let projectFolderPath = ""
+let projectFolderPath = "";
 
 beforeEach(async () => {
-  setupActivePinia()
-  ;({ projectFolderPath } = await runMicroservices())
-})
+  setupActivePinia();
+  ({ projectFolderPath } = await runMicroservices());
+});
 
 afterEach(async () => {
-  await cleanupBackend(projectFolderPath)
-})
+  await cleanupBackend(projectFolderPath);
+});
 
 describe("Viewer Store", () => {
   describe("actions", () => {
@@ -30,44 +30,41 @@ describe("Viewer Store", () => {
       test(
         "ws_connect",
         async () => {
-          const viewerStore = useViewerStore()
-          await viewerStore.ws_connect()
-          expect(viewerStore.status).toBe(Status.CONNECTED)
+          const viewerStore = useViewerStore();
+          await viewerStore.ws_connect();
+          expect(viewerStore.status).toBe(Status.CONNECTED);
         },
         CONNECT_TIMEOUT,
-      )
-    })
+      );
+    });
     describe("connect", () => {
       test(
         "connect",
         async () => {
-          const viewerStore = useViewerStore()
-          await viewerStore.connect()
-          expect(viewerStore.status).toBe(Status.CONNECTED)
+          const viewerStore = useViewerStore();
+          await viewerStore.connect();
+          expect(viewerStore.status).toBe(Status.CONNECTED);
         },
         CONNECT_TIMEOUT,
-      )
-    })
+      );
+    });
 
     describe("request", () => {
       test(
         "request",
-        async () => {
-          const schema =
-            opengeodeweb_viewer_schemas.opengeodeweb_viewer.viewer.render
-          const viewerStore = useViewerStore()
-          const timeout = 1
-          const params = {}
+        () => {
+          const schema = opengeodeweb_viewer_schemas.opengeodeweb_viewer.viewer.render;
+          const viewerStore = useViewerStore();
+          const timeout = 1;
+          const params = {};
           expect(() =>
             viewerStore
               .request(schema, params, {}, timeout)
-              .rejects.toThrow(
-                `${schema.$id}: Timed out after ${timeout}ms, ${schema} ${params}`,
-              ),
-          )
+              .rejects.toThrow(`${schema.$id}: Timed out after ${timeout}ms, ${schema} ${params}`),
+          );
         },
         CONNECT_TIMEOUT,
-      )
-    })
-  })
-})
+      );
+    });
+  });
+});

package/tests/setup_indexeddb.js

@@ -1,4 +1,4 @@
-import { setup } from "vitest-indexeddb"
+import { setup } from "vitest-indexeddb";
 
 // oxlint-disable-next-line jest/require-hook
-setup()
+setup();