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

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

@@ -1,109 +1,92 @@
 // 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_blocks_schemas = viewer_schemas.opengeodeweb_viewer.model.blocks
-const file_name = "test.og_brep"
-const geode_object = "BRep"
+const INTERVAL_TIMEOUT = 20_000;
+const model_blocks_schemas = viewer_schemas.opengeodeweb_viewer.model.blocks;
+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 blocks kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach model blocks kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 
 describe("Model blocks", () => {
   describe("Blocks visibility", () => {
     test("Visibility false", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const dataStore = useDataStore()
-      const block_ids = await dataStore.getBlocksGeodeIds(id)
-      const block_viewer_ids = await dataStore.getMeshComponentsViewerIds(
-        id,
-        block_ids,
-      )
-      const visibility = false
-      const spy = vi.spyOn(viewerStore, "request")
-      spy.mockClear()
-      const result = dataStyleStore.setModelBlocksVisibility(
-        id,
-        block_ids,
-        visibility,
-      )
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const block_ids = await dataStore.getBlocksGeodeIds(id);
+      const block_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, block_ids);
+      const visibility = false;
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelBlocksVisibility(id, block_ids, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         model_blocks_schemas.visibility,
         { id, block_ids: block_viewer_ids, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
+      );
       for (const block_id of block_ids) {
-        expect(dataStyleStore.modelBlockVisibility(id, block_id)).toBe(
-          visibility,
-        )
+        expect(dataStyleStore.modelBlockVisibility(id, block_id)).toBe(visibility);
       }
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Blocks color", () => {
     test("Color red", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const dataStore = useDataStore()
-      const block_ids = await dataStore.getBlocksGeodeIds(id)
-      const block_viewer_ids = await dataStore.getMeshComponentsViewerIds(
-        id,
-        block_ids,
-      )
-      const color = { r: 255, g: 0, b: 0 }
-      const spy = vi.spyOn(viewerStore, "request")
-      await dataStyleStore.setModelBlocksColor(id, block_ids, color)
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const block_ids = await dataStore.getBlocksGeodeIds(id);
+      const block_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, block_ids);
+      const color = { r: 255, g: 0, b: 0 };
+      const spy = vi.spyOn(viewerStore, "request");
+      await dataStyleStore.setModelBlocksColor(id, block_ids, color);
       expect(spy).toHaveBeenCalledWith(
         model_blocks_schemas.color,
         { id, block_ids: block_viewer_ids, color },
         {
           response_function: expect.any(Function),
         },
-      )
+      );
       for (const block_id of block_ids) {
-        expect(dataStyleStore.modelBlockColor(id, block_id)).toStrictEqual(
-          color,
-        )
+        expect(dataStyleStore.modelBlockColor(id, block_id)).toStrictEqual(color);
       }
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
   describe("Blocks style", () => {
     test("Blocks apply style", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const result = dataStyleStore.applyModelBlocksStyle(id)
-      expect(result).toBeInstanceOf(Promise)
-      await result
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
-})
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const result = dataStyleStore.applyModelBlocksStyle(id);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+});

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

@@ -1,113 +1,96 @@
 // 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_corners_schemas = viewer_schemas.opengeodeweb_viewer.model.corners
-const file_name = "test.og_brep"
-const geode_object = "BRep"
+const INTERVAL_TIMEOUT = 20_000;
+const model_corners_schemas = viewer_schemas.opengeodeweb_viewer.model.corners;
+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 corners kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach model corners kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 
 describe("Model corners", () => {
   describe("Corners visibility", () => {
     test("Visibility false", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const dataStore = useDataStore()
-      const corner_ids = await dataStore.getCornersGeodeIds(id)
-      const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(
-        id,
-        corner_ids,
-      )
-      const visibility = false
-      const spy = vi.spyOn(viewerStore, "request")
-      spy.mockClear()
-      const result = dataStyleStore.setModelCornersVisibility(
-        id,
-        corner_ids,
-        visibility,
-      )
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const corner_ids = await dataStore.getCornersGeodeIds(id);
+      const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, corner_ids);
+      const visibility = false;
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelCornersVisibility(id, corner_ids, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         model_corners_schemas.visibility,
         { id, block_ids: corner_viewer_ids, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
+      );
       for (const corner_id of corner_ids) {
-        expect(dataStyleStore.modelCornerVisibility(id, corner_id)).toBe(
-          visibility,
-        )
+        expect(dataStyleStore.modelCornerVisibility(id, corner_id)).toBe(visibility);
       }
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Corner color", () => {
     test("Color red", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const dataStore = useDataStore()
-      const corner_ids = await dataStore.getCornersGeodeIds(id)
-      const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(
-        id,
-        corner_ids,
-      )
-      const color = { r: 255, g: 0, b: 0 }
-      const spy = vi.spyOn(viewerStore, "request")
-      spy.mockClear()
-      const result = dataStyleStore.setModelCornersColor(id, corner_ids, color)
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const dataStore = useDataStore();
+      const corner_ids = await dataStore.getCornersGeodeIds(id);
+      const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, corner_ids);
+      const color = { r: 255, g: 0, b: 0 };
+      const spy = vi.spyOn(viewerStore, "request");
+      spy.mockClear();
+      const result = dataStyleStore.setModelCornersColor(id, corner_ids, color);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         model_corners_schemas.color,
         { id, block_ids: corner_viewer_ids, color },
         {
           response_function: expect.any(Function),
         },
-      )
+      );
       for (const corner_id of corner_ids) {
-        expect(dataStyleStore.modelCornerColor(id, corner_id)).toStrictEqual(
-          color,
-        )
+        expect(dataStyleStore.modelCornerColor(id, corner_id)).toStrictEqual(color);
       }
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Corner style", () => {
     test("Corners apply style", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const result = dataStyleStore.applyModelCornersStyle(id)
-      expect(result).toBeInstanceOf(Promise)
-      await result
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
-})
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const result = dataStyleStore.applyModelCornersStyle(id);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+});

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

@@ -1,65 +1,62 @@
 // 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 = 25_000
-const model_edges_schemas = viewer_schemas.opengeodeweb_viewer.model.edges
-const file_name = "test.og_brep"
-const geode_object = "BRep"
+const INTERVAL_TIMEOUT = 25_000;
+const model_edges_schemas = viewer_schemas.opengeodeweb_viewer.model.edges;
+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 edges kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach model edges kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 
 describe("Model edges", () => {
   describe("Edges 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.setModelEdgesVisibility(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.setModelEdgesVisibility(id, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         model_edges_schemas.visibility,
         { id, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.modelEdgesVisibility(id)).toBe(visibility)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.modelEdgesVisibility(id)).toBe(visibility);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
   describe("Edges style", () => {
     test("Edges apply style", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const result = dataStyleStore.applyModelEdgesStyle(id)
-      expect(result).toBeInstanceOf(Promise)
-      await result
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
-})
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const result = dataStyleStore.applyModelEdgesStyle(id);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+});

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

@@ -1,55 +1,52 @@
 // 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_schemas = viewer_schemas.opengeodeweb_viewer.model
-const file_name = "test.og_brep"
-const geode_object = "BRep"
+const INTERVAL_TIMEOUT = 20_000;
+const model_schemas = viewer_schemas.opengeodeweb_viewer.model;
+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 kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach model kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 
 describe("Model", () => {
   describe("Model 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.setModelVisibility(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.setModelVisibility(id, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         model_schemas.visibility,
         { id, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.modelVisibility(id)).toBe(visibility)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
-})
+      );
+      expect(dataStyleStore.modelVisibility(id)).toBe(visibility);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
+});