@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

package/shared/utils/fetch_raw.js

@@ -1,61 +0,0 @@
-// Third party imports
-import { $fetch } from "ofetch";
-import _ from "lodash";
-import pTimeout from "p-timeout";
-
-// Local imports
-import { hasBody } from "./file.js";
-
-function fetchRaw(
-  { route, method, params = {}, baseURL, headers = {}, max_retry, timeout, expectEvent = false },
-  { request_error_function, response_function, response_error_function } = {},
-) {
-  if (expectEvent) {
-    const value = "text/event-stream";
-    if (_.isEmpty(headers)) {
-      headers["Accept"] = value;
-    } else {
-      headers["Accept"] = `${headers["Accept"]}, ${value}`;
-    }
-  }
-
-  const request_options = { method, headers };
-  if (hasBody(params)) {
-    request_options.body = params;
-  }
-  if (max_retry) {
-    request_options.max_retry = max_retry;
-  }
-
-  function doFetch() {
-    return $fetch(route, {
-      baseURL,
-      ...request_options,
-      onRequestError({ error }) {
-        if (request_error_function) {
-          request_error_function(error);
-        }
-      },
-      onResponse({ response }) {
-        if (response.ok && response_function) {
-          response_function(response._data);
-        }
-      },
-      onResponseError({ response }) {
-        if (response_error_function) {
-          response_error_function(response);
-        }
-      },
-    });
-  }
-
-  if (timeout > 0) {
-    return pTimeout(doFetch(), {
-      milliseconds: timeout,
-      message: `${route}: Timed out after ${timeout}ms`,
-    });
-  }
-  return doFetch();
-}
-
-export { fetchRaw };

package/shared/utils/file.js

@@ -1,16 +0,0 @@
-import _ from "lodash";
-
-function assertFile(file) {
-  console.log("[ASSERT_FILE] Asserting file", { file });
-  if (!(file instanceof File)) {
-    throw new Error("file must be an instance of File");
-  }
-}
-
-function hasBody(params) {
-  if (params instanceof FormData || params instanceof Blob) {
-    return true;
-  }
-  return !_.isEmpty(params);
-}
-export { assertFile, hasBody };

package/shared/utils/response_handlers/load.js

@@ -1,74 +0,0 @@
-function getFileExtension(filename) {
-  return filename.slice(filename.lastIndexOf(".") + 1);
-}
-
-function selectGeodeObject(objectMap) {
-  const objectKeys = Object.keys(objectMap);
-  if (objectKeys.length === 0) {
-    return undefined;
-  }
-  if (objectKeys.length === 1 && objectMap[objectKeys[0]].is_loadable > 0) {
-    return objectKeys[0];
-  }
-
-  const highestLoadScore = Math.max(...objectKeys.map((key) => objectMap[key].is_loadable));
-  if (highestLoadScore <= 0) {
-    return undefined;
-  }
-
-  const bestScoreObjects = objectKeys.filter(
-    (key) => objectMap[key].is_loadable === highestLoadScore,
-  );
-  if (bestScoreObjects.length === 1) {
-    return bestScoreObjects[0];
-  }
-
-  const highestPriority = Math.max(
-    ...bestScoreObjects.map((key) => objectMap[key].object_priority ?? -Infinity),
-  );
-  const bestPriorityObjects = bestScoreObjects.filter(
-    (key) => objectMap[key].object_priority === highestPriority,
-  );
-  if (highestPriority !== -Infinity && bestPriorityObjects.length === 1) {
-    return bestPriorityObjects[0];
-  }
-
-  return undefined;
-}
-
-function intersectAllowedObjects(allowedObjectsList) {
-  const allKeys = [...new Set(allowedObjectsList.flatMap((object) => Object.keys(object)))];
-  const commonKeys = allKeys.filter((key) => allowedObjectsList.every((object) => key in object));
-
-  const mergedAllowedObjects = {};
-  for (const key of commonKeys) {
-    const loadScores = allowedObjectsList.map((object) => object[key].is_loadable);
-    const priorities = allowedObjectsList
-      .map((object) => object[key].object_priority)
-      .filter((priority) => priority !== undefined);
-
-    mergedAllowedObjects[key] = { is_loadable: Math.min(...loadScores) };
-    if (priorities.length > 0) {
-      mergedAllowedObjects[key].object_priority = Math.max(...priorities);
-    }
-  }
-
-  return { commonKeys, allKeys, mergedAllowedObjects };
-}
-
-function resolveAllowedObjects(filenames, allowedObjectsList) {
-  const { commonKeys, allKeys, mergedAllowedObjects } = intersectAllowedObjects(allowedObjectsList);
-
-  const multipleFilesNoCommon =
-    filenames.length > 1 && allKeys.length > 0 && commonKeys.length === 0;
-
-  const selectedGeodeObject = selectGeodeObject(mergedAllowedObjects);
-
-  return {
-    mergedAllowedObjects,
-    multipleFilesNoCommon,
-    selectedGeodeObject,
-  };
-}
-
-export { resolveAllowedObjects, getFileExtension };

package/tests/integration/data/uploads/test.vtu

@@ -1,22 +0,0 @@
-<?xml version="1.0"?>
-<VTKFile type="UnstructuredGrid" version="1.0" byte_order="LittleEndian" header_type="UInt32" compressor="vtkZLibDataCompressor">
-	<UnstructuredGrid>
-		<Piece NumberOfPoints="11" NumberOfCells="4">
-			<PointData>
-				<DataArray type="Float64" Name="toto_on_vertices" format="ascii" NumberOfComponents="1" RangeMin="1" RangeMax="11">1 2 3 4 5 6 7 8 9 10 11 </DataArray>
-				<DataArray type="Float64" Name="points" format="ascii" NumberOfComponents="3" RangeMin="0" RangeMax="2">0 0 0 1 0 0 2 1 0 1 2 0 0 2 0 0 0 1 1 0 1 2 1 1 1 2 1 0 2 1 1 1 2 </DataArray>
-			</PointData>
-			<Points>
-				<DataArray type="Float64" Name="Points" format="ascii" NumberOfComponents="3" RangeMin="0" RangeMax="2">0 0 0 1 0 0 2 1 0 1 2 0 0 2 0 0 0 1 1 0 1 2 1 1 1 2 1 0 2 1 1 1 2 </DataArray>
-			</Points>
-			<CellData>
-				<DataArray type="Float64" Name="toto_on_polyhedra" format="ascii" NumberOfComponents="1" RangeMin="3" RangeMax="6">3 4 5 6 </DataArray>
-			</CellData>
-			<Cells>
-				<DataArray type="Int64" Name="connectivity" format="ascii" RangeMin="0" RangeMax="10">0 1 3 4 5 6 8 9 1 2 3 6 7 8 5 6 8 9 10 6 7 8 10 </DataArray>
-				<DataArray type="Int64" Name="offsets" format="ascii" RangeMin="0" RangeMax="11">8 14 19 23 </DataArray>
-				<DataArray type="UInt8" Name="types" format="ascii" RangeMin="1" RangeMax="42">12 13 14 10 </DataArray>
-			</Cells>
-		</Piece>
-	</UnstructuredGrid>
-</VTKFile>

package/tests/integration/setup.js

@@ -1,92 +0,0 @@
-// oxlint-disable vitest/require-top-level-describe
-
-// Node.js imports
-import { WebSocket } from "ws";
-import path from "node:path";
-
-// Third party imports
-import { afterAll, beforeAll, expect, vi } from "vitest";
-
-// Local imports
-import { addMicroserviceMetadatas, runBack, runViewer } from "@ogw_server/utils/microservices";
-import { createPath, generateProjectFolderPath } from "@ogw_server/utils/path";
-import { Status } from "@ogw_front/utils/status";
-import { appMode } from "@ogw_shared/app_mode";
-import { importFile } from "@ogw_front/utils/import_workflow";
-import { setupActivePinia } from "@ogw_tests/utils";
-import { useBackStore } from "@ogw_front/stores/back";
-import { useInfraStore } from "@ogw_front/stores/infra";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-
-// Local constants
-const beforeAllTimeout = 40_000;
-const data_folder = path.join("tests", "integration", "data", "uploads");
-
-async function runMicroservices() {
-  const backStore = useBackStore();
-  const infraStore = useInfraStore();
-  const viewerStore = useViewerStore();
-  infraStore.app_mode = appMode.BROWSER;
-  const { COMMAND_BACK, PROJECT, COMMAND_VIEWER, NUXT_ROOT_PATH } = useRuntimeConfig().public;
-  const projectFolderPath = generateProjectFolderPath(PROJECT);
-  await createPath(projectFolderPath);
-
-  const [back_port, viewer_port] = await Promise.all([
-    runBack(COMMAND_BACK, NUXT_ROOT_PATH, {
-      projectFolderPath,
-      uploadFolderPath: data_folder,
-    }),
-    runViewer(COMMAND_VIEWER, NUXT_ROOT_PATH, { projectFolderPath }),
-  ]);
-
-  console.log("back_port", back_port);
-  console.log("viewer_port", viewer_port);
-
-  await addMicroserviceMetadatas(projectFolderPath, {
-    type: "back",
-    name: COMMAND_BACK,
-    port: back_port,
-  });
-  await addMicroserviceMetadatas(projectFolderPath, {
-    type: "viewer",
-    name: COMMAND_VIEWER,
-    port: viewer_port,
-  });
-
-  backStore.default_local_port = back_port;
-  viewerStore.default_local_port = viewer_port;
-
-  return {
-    projectFolderPath,
-  };
-}
-
-async function setupIntegrationTests(file_name, geode_object) {
-  setupActivePinia();
-  const viewerStore = useViewerStore();
-  const { projectFolderPath } = await runMicroservices();
-  await viewerStore.ws_connect();
-  const id = await importFile(file_name, geode_object);
-  expect(viewerStore.status).toBe(Status.CONNECTED);
-  console.log("end of setupIntegrationTests", { id, projectFolderPath });
-  return { id, projectFolderPath };
-}
-
-const mockLockRequest = vi.fn().mockImplementation(async (name, task) => await task({ name }));
-
-vi.stubGlobal("navigator", {
-  ...navigator,
-  locks: {
-    request: mockLockRequest,
-  },
-});
-
-beforeAll(() => {
-  globalThis.WebSocket = WebSocket;
-});
-
-afterAll(() => {
-  delete globalThis.WebSocket;
-});
-
-export { beforeAllTimeout, runMicroservices, setupIntegrationTests };

package/tests/integration/stores/data_style/mesh/cells.nuxt.test.js

@@ -1,343 +0,0 @@
-// oxlint-disable max-lines
-// Third party imports
-import { afterAll, beforeAll, describe, expect, test, vi } from "vitest";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" };
-
-// Local imports
-import { beforeAllTimeout, setupIntegrationTests } from "@ogw_tests/integration/setup";
-import { DEFAULT_NO_DATA_COLOR } from "@ogw_front/utils/default_styles/constants";
-import { Status } from "@ogw_front/utils/status";
-import { cleanupBackend } from "@ogw_server/utils/cleanup";
-import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
-import { isMeshCellsVertexAttributeValid } from "@ogw_internal/stores/data_style/mesh/cells/vertex";
-import { useDataStyleStore } from "@ogw_front/stores/data_style";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-
-// Local constants
-const mesh_cells_schemas = viewer_schemas.opengeodeweb_viewer.mesh.cells;
-const file_name = "test.og_rgd2d";
-const geode_object = "RegularGrid2D";
-const MINIMUM_RANGE = 10;
-const MAXIMUM_RANGE = 20;
-const ALTERNATE_RANGE_MAX = 100;
-const range = [MINIMUM_RANGE, MAXIMUM_RANGE];
-const default_vertex_attribute = { name: "points", item: 0, range };
-const default_cell_attribute = { name: "RGB_data", item: 0, range };
-
-let id = "";
-let projectFolderPath = "";
-
-describe("mesh cells", () => {
-  beforeAll(async () => {
-    id = "";
-    projectFolderPath = "";
-    ({ id, projectFolderPath } = await setupIntegrationTests(file_name, geode_object));
-  }, beforeAllTimeout);
-
-  afterAll(async () => {
-    console.log("afterAll mesh cells kill", projectFolderPath);
-    await cleanupBackend(projectFolderPath);
-  });
-
-  describe("cells visibility", () => {
-    test("visibility true", async () => {
-      const dataStyleStore = useDataStyleStore();
-      const viewerStore = useViewerStore();
-      const visibility = true;
-      const spy = vi.spyOn(viewerStore, "request");
-      const result = dataStyleStore.setMeshCellsVisibility(id, visibility);
-      expect(result).toBeInstanceOf(Promise);
-      await result;
-      const schema = mesh_cells_schemas.visibility;
-      const params = { id, visibility };
-      expect(spy).toHaveBeenCalledWith(
-        { schema, params },
-        {
-          response_function: expect.any(Function),
-        },
-      );
-      expect(dataStyleStore.meshCellsVisibility(id)).toBe(visibility);
-      expect(viewerStore.status).toBe(Status.CONNECTED);
-    });
-  });
-
-  describe("cells color", () => {
-    test("color red", async () => {
-      const dataStyleStore = useDataStyleStore();
-      const viewerStore = useViewerStore();
-      const color = { red: 255, green: 0, blue: 0, alpha: 1 };
-      const spy = vi.spyOn(viewerStore, "request");
-      const result = dataStyleStore.setMeshCellsColor(id, color);
-      expect(result).toBeInstanceOf(Promise);
-      await result;
-      const schema = mesh_cells_schemas.color;
-      const params = { id, color };
-      expect(spy).toHaveBeenCalledWith(
-        { schema, params },
-        {
-          response_function: expect.any(Function),
-        },
-      );
-      expect(dataStyleStore.meshCellsColor(id)).toStrictEqual(color);
-      expect(viewerStore.status).toBe(Status.CONNECTED);
-    });
-  });
-
-  describe("cells vertex attribute", () => {
-    test("coloring vertex attribute - guard on missing parameters", () => {
-      expect(
-        isMeshCellsVertexAttributeValid({
-          name: "points",
-          item: 0,
-          minimum: undefined,
-          maximum: undefined,
-          colorMap: undefined,
-        }),
-      ).toBe(false);
-    });
-
-    test("coloring vertex attribute - set range and colormap", async () => {
-      const dataStyleStore = useDataStyleStore();
-      const viewerStore = useViewerStore();
-      const spy = vi.spyOn(viewerStore, "request");
-      const vertex_attribute = { name: "points", item: 2 };
-      const colorMap = "budaS";
-      const result = dataStyleStore.setMeshCellsVertexAttribute(id, {
-        name: vertex_attribute.name,
-        item: vertex_attribute.item,
-        minimum: range[0],
-        maximum: range[1],
-        colorMap,
-      });
-      expect(result).toBeInstanceOf(Promise);
-      await result;
-      const schema = mesh_cells_schemas.attribute.vertex.attribute;
-      const name = dataStyleStore.meshCellsVertexAttributeName(id);
-      const item = dataStyleStore.meshCellsVertexAttributeItem(id);
-      expect(spy).toHaveBeenCalledWith({
-        schema,
-        params: expect.objectContaining({ id, name, item, minimum: range[0], maximum: range[1] }),
-      });
-      expect(dataStyleStore.meshCellsVertexAttributeRange(id)).toStrictEqual(range);
-      expect(dataStyleStore.meshCellsVertexAttributeColorMap(id)).toBe(colorMap);
-    });
-
-    test("coloring vertex attribute - item switching", async () => {
-      const dataStyleStore = useDataStyleStore();
-      const viewerStore = useViewerStore();
-      const spy = vi.spyOn(viewerStore, "request");
-      const schema = mesh_cells_schemas.attribute.vertex.attribute;
-
-      await dataStyleStore.setMeshCellsVertexAttribute(id, {
-        name: "points",
-        item: 0,
-        minimum: 0,
-        maximum: MAXIMUM_RANGE,
-        colorMap: "batlow",
-      });
-      dataStyleStore.setMeshCellsVertexAttributeColorMap(id, "oleron");
-      dataStyleStore.setMeshCellsVertexAttributeRange(id, MINIMUM_RANGE, ALTERNATE_RANGE_MAX);
-      await dataStyleStore.setMeshCellsVertexAttribute(id, {
-        name: "points",
-        item: 0,
-        minimum: MINIMUM_RANGE,
-        maximum: ALTERNATE_RANGE_MAX,
-        colorMap: "oleron",
-      });
-
-      dataStyleStore.setMeshCellsVertexAttributeItem(id, 1);
-      await dataStyleStore.setMeshCellsVertexAttribute(id, {
-        name: "points",
-        item: 1,
-        minimum: 0,
-        maximum: MAXIMUM_RANGE,
-        colorMap: "berlin",
-      });
-      expect(dataStyleStore.meshCellsVertexAttributeItem(id)).toBe(1);
-      expect(dataStyleStore.meshCellsVertexAttributeRange(id)).toStrictEqual([0, MAXIMUM_RANGE]);
-      expect(spy).toHaveBeenCalledWith({
-        schema,
-        params: expect.objectContaining({
-          id,
-          name: "points",
-          item: 1,
-          minimum: 0,
-          maximum: MAXIMUM_RANGE,
-        }),
-      });
-    });
-
-    test("stored configs - restore previous item config", async () => {
-      const dataStyleStore = useDataStyleStore();
-      dataStyleStore.setMeshCellsVertexAttributeItem(id, 0);
-      const storedConfig0 = dataStyleStore.meshCellsVertexAttributeStoredConfig(id, "points", 0);
-      await dataStyleStore.setMeshCellsVertexAttribute(id, {
-        name: "points",
-        item: 0,
-        minimum: storedConfig0.minimum,
-        maximum: storedConfig0.maximum,
-        colorMap: storedConfig0.colorMap,
-      });
-      expect(dataStyleStore.meshCellsVertexAttributeItem(id)).toBe(0);
-      expect(dataStyleStore.meshCellsVertexAttributeRange(id)).toStrictEqual([
-        MINIMUM_RANGE,
-        ALTERNATE_RANGE_MAX,
-      ]);
-      expect(dataStyleStore.meshCellsVertexAttributeColorMap(id)).toBe("oleron");
-    });
-
-    test("stored configs - select polygon_arround_vertex", async () => {
-      const dataStyleStore = useDataStyleStore();
-      const result = dataStyleStore.setMeshCellsVertexAttribute(id, {
-        name: "polygon_arround_vertex",
-        item: 0,
-        minimum: 0,
-        maximum: MINIMUM_RANGE,
-        colorMap: "batlow",
-      });
-      expect(result).toBeInstanceOf(Promise);
-      await result;
-      expect(dataStyleStore.meshCellsVertexAttributeName(id)).toBe("polygon_arround_vertex");
-      expect(dataStyleStore.meshCellsVertexAttributeItem(id)).toBe(0);
-      expect(dataStyleStore.meshCellsVertexAttributeRange(id)).toStrictEqual([0, MINIMUM_RANGE]);
-      expect(dataStyleStore.meshCellsVertexAttributeColorMap(id)).toBe("batlow");
-    });
-
-    test("stored configs - switch back to points and verify state restoration", async () => {
-      const dataStyleStore = useDataStyleStore();
-      const vertex_attribute = { name: "points", item: 2 };
-      const result = dataStyleStore.setMeshCellsVertexAttribute(id, {
-        name: vertex_attribute.name,
-        item: vertex_attribute.item,
-        minimum: range[0],
-        maximum: range[1],
-        colorMap: "budaS",
-      });
-      expect(result).toBeInstanceOf(Promise);
-      await result;
-      expect(dataStyleStore.meshCellsVertexAttributeName(id)).toBe(vertex_attribute.name);
-      expect(dataStyleStore.meshCellsVertexAttributeItem(id)).toBe(vertex_attribute.item);
-      expect(dataStyleStore.meshCellsVertexAttributeRange(id)).toStrictEqual(range);
-      expect(dataStyleStore.meshCellsVertexAttributeColorMap(id)).toBe("budaS");
-    });
-  });
-
-  describe("cells cell attribute", () => {
-    test("coloring cell attribute", async () => {
-      const dataStyleStore = useDataStyleStore();
-      const viewerStore = useViewerStore();
-      const spy = vi.spyOn(viewerStore, "request");
-      const cell_attribute = {
-        name: default_cell_attribute.name,
-        item: default_cell_attribute.item,
-        minimum: range[0],
-        maximum: range[1],
-        colorMap: "batlow",
-      };
-      const result = dataStyleStore.setMeshCellsCellAttribute(id, cell_attribute);
-      expect(result).toBeInstanceOf(Promise);
-      await result;
-      const schema = mesh_cells_schemas.attribute.cell.attribute;
-      const points = getRGBPointsFromPreset(cell_attribute.colorMap);
-      const params = {
-        id,
-        name: cell_attribute.name,
-        item: cell_attribute.item,
-        points,
-        minimum: cell_attribute.minimum,
-        maximum: cell_attribute.maximum,
-        no_data_color: DEFAULT_NO_DATA_COLOR,
-      };
-      expect(spy).toHaveBeenCalledWith({ schema, params });
-      expect(dataStyleStore.meshCellsCellAttributeName(id)).toBe(cell_attribute.name);
-      expect(viewerStore.status).toBe(Status.CONNECTED);
-    });
-
-    test("stored configs 1 - select attribute RGB_data and item 2", async () => {
-      const dataStyleStore = useDataStyleStore();
-      const cell_attribute = { name: "RGB_data", item: 2 };
-      await dataStyleStore.setMeshCellsCellAttributeName(id, cell_attribute.name);
-      await dataStyleStore.setMeshCellsCellAttributeItem(id, cell_attribute.item);
-      expect(dataStyleStore.meshCellsCellAttributeName(id)).toBe(cell_attribute.name);
-      expect(dataStyleStore.meshCellsCellAttributeItem(id)).toBe(cell_attribute.item);
-    });
-
-    test("stored configs 2 - set range and colormap", async () => {
-      const dataStyleStore = useDataStyleStore();
-      await dataStyleStore.setMeshCellsCellAttributeRange(id, range[0], range[1]);
-      await dataStyleStore.setMeshCellsCellAttributeColorMap(id, "budaS");
-      expect(dataStyleStore.meshCellsCellAttributeRange(id)).toStrictEqual(range);
-      expect(dataStyleStore.meshCellsCellAttributeColorMap(id)).toBe("budaS");
-    });
-
-    test("stored configs 3 - select dummy_attribute", async () => {
-      const dataStyleStore = useDataStyleStore();
-      await dataStyleStore.setMeshCellsCellAttributeName(id, "dummy_attribute");
-      await dataStyleStore.setMeshCellsCellAttributeItem(id, 0);
-      expect(dataStyleStore.meshCellsCellAttributeName(id)).toBe("dummy_attribute");
-      expect(dataStyleStore.meshCellsCellAttributeItem(id)).toBe(0);
-    });
-
-    test("stored configs 4 - switch back to RGB_data and verify restoration", async () => {
-      const dataStyleStore = useDataStyleStore();
-      const cell_attribute = { name: "RGB_data", item: 2 };
-      await dataStyleStore.setMeshCellsCellAttributeName(id, cell_attribute.name);
-      expect(dataStyleStore.meshCellsCellAttributeName(id)).toBe(cell_attribute.name);
-      expect(dataStyleStore.meshCellsCellAttributeItem(id)).toBe(cell_attribute.item);
-      expect(dataStyleStore.meshCellsCellAttributeRange(id)).toStrictEqual(range);
-      expect(dataStyleStore.meshCellsCellAttributeColorMap(id)).toBe("budaS");
-    });
-  });
-
-  describe("cells active coloring", () => {
-    test("coloring color", async () => {
-      const dataStyleStore = useDataStyleStore();
-      const viewerStore = useViewerStore();
-      const coloringName = "constant";
-      const result = dataStyleStore.setMeshCellsActiveColoring(id, coloringName);
-      expect(result).toBeInstanceOf(Promise);
-      await result;
-      expect(dataStyleStore.meshCellsActiveColoring(id)).toBe(coloringName);
-      expect(viewerStore.status).toBe(Status.CONNECTED);
-    });
-
-    test("coloring vertex", async () => {
-      const dataStyleStore = useDataStyleStore();
-      const viewerStore = useViewerStore();
-      await dataStyleStore.setMeshCellsVertexAttribute(id, {
-        name: default_vertex_attribute.name,
-        item: default_vertex_attribute.item,
-        minimum: default_vertex_attribute.range[0],
-        maximum: default_vertex_attribute.range[1],
-        colorMap: "batlow",
-      });
-      const coloringName = "vertex";
-      const result = dataStyleStore.setMeshCellsActiveColoring(id, coloringName);
-      expect(result).toBeInstanceOf(Promise);
-      await result;
-      expect(dataStyleStore.meshCellsActiveColoring(id)).toBe(coloringName);
-      expect(viewerStore.status).toBe(Status.CONNECTED);
-    });
-
-    test("coloring cell", async () => {
-      const dataStyleStore = useDataStyleStore();
-      const viewerStore = useViewerStore();
-      await dataStyleStore.setMeshCellsCellAttributeName(id, default_cell_attribute.name);
-      const coloringName = "cell";
-      const result = dataStyleStore.setMeshCellsActiveColoring(id, coloringName);
-      expect(result).toBeInstanceOf(Promise);
-      await result;
-      expect(dataStyleStore.meshCellsActiveColoring(id)).toBe(coloringName);
-      expect(viewerStore.status).toBe(Status.CONNECTED);
-    });
-  });
-
-  test("cells apply default style", async () => {
-    const dataStyleStore = useDataStyleStore();
-    const viewerStore = useViewerStore();
-    const result = dataStyleStore.applyMeshCellsStyle(id);
-    expect(result).toBeInstanceOf(Promise);
-    await result;
-    expect(viewerStore.status).toBe(Status.CONNECTED);
-  });
-});