Move integration test to performance tests

Author: JonasDov

apps/performance-tests/src/tree-widget/ModelsTree.test.ts

@@ -72,6 +72,67 @@ describe("models tree", () => {
     },
   });
 
+  run<{
+    iModel: SnapshotDb;
+    idsCache: ModelsTreeIdsCache;
+    imodelAccess: IModelAccess;
+    viewport: Viewport;
+    handler: HierarchyVisibilityHandler & Disposable;
+    provider: HierarchyProvider & Disposable;
+    elementsModel: Id64String;
+  }>({
+    testName: "validates categories visibility for imodel with 50k categories",
+    setup: async () => {
+      const { iModelConnection, iModel } = TestIModelConnection.openFile(Datasets.getIModelPath("50k categories"));
+      const imodelAccess = StatelessHierarchyProvider.createIModelAccess(iModel, "unbounded");
+      const visibilityTargets = await getVisibilityTargets(imodelAccess);
+      const testData = createTestDataForInitialDisplay({ visibilityTargets, visible: false });
+
+      const viewport = await createViewport({
+        iModelConnection,
+        testData,
+      });
+      setupInitialDisplayState({
+        viewport,
+        ...testData,
+      });
+      const idsCache = new ModelsTreeIdsCache(imodelAccess, defaultModelsTreeHierarchyConfiguration);
+      const handler = createModelsTreeVisibilityHandler({ idsCache, viewport, imodelAccess });
+      const provider = createIModelHierarchyProvider({
+        hierarchyDefinition: new ModelsTreeDefinition({ idsCache, imodelAccess, hierarchyConfig: defaultModelsTreeHierarchyConfiguration }),
+        imodelAccess,
+      });
+      await validateHierarchyVisibility({
+        ignoreChildren: (node) => !!node.extendedData?.isCategory,
+        provider,
+        handler,
+        viewport,
+        expectations: "all-hidden",
+      });
+      const elementsModel = iModel.elements.getElementProps(visibilityTargets.elements[0]).model;
+      return { iModel, imodelAccess, viewport, provider, handler, elementsModel, idsCache };
+    },
+    cleanup: async (props) => {
+      props.iModel.close();
+      props.viewport[Symbol.dispose]();
+      props.handler[Symbol.dispose]();
+      props.provider[Symbol.dispose]();
+      props.idsCache[Symbol.dispose]();
+    },
+    test: async ({ viewport, handler, provider, elementsModel }) => {
+      // Add one element to always draw set to trigger additional queries
+      viewport.setAlwaysDrawn(new Set([elementsModel]));
+      await handler.changeVisibility(createModelHierarchyNode(elementsModel), true);
+      await validateHierarchyVisibility({
+        ignoreChildren: (node) => !!node.extendedData?.isCategory,
+        provider,
+        handler,
+        viewport,
+        expectations: "all-visible",
+      });
+    },
+  });
+
   run<{
     iModel: SnapshotDb;
     idsCache: ModelsTreeIdsCache;

apps/performance-tests/src/tree-widget/VisibilityUtilities.ts

@@ -22,6 +22,7 @@ import type { IModelConnection, Viewport } from "@itwin/core-frontend";
 type Visibility = "visible" | "hidden" | "partial";
 
 export interface ValidateNodeProps {
+  ignoreChildren?: (node: HierarchyNode) => boolean;
   handler: HierarchyVisibilityHandler;
   viewport: Viewport;
   expectations:
@@ -44,7 +45,7 @@ async function validateNodeVisibility({ node, handler, expectations }: ValidateN
     expect(actualVisibility.state).to.eq(expectations === "all-hidden" ? "hidden" : "visible");
     return;
   }
-  const idInExpectations = ids.find((id) => id in expectations.instances)
+  const idInExpectations = ids.find((id) => id in expectations.instances);
   if (idInExpectations) {
     const expectedVisibility = expectations.instances[idInExpectations];
     expect(actualVisibility.state).to.eq(expectedVisibility);
@@ -55,14 +56,15 @@ async function validateNodeVisibility({ node, handler, expectations }: ValidateN
 
 export async function validateHierarchyVisibility({
   provider,
+  ignoreChildren,
   ...props
 }: ValidateNodeProps & {
   provider: HierarchyProvider;
 }) {
   await toVoidPromise(
     from(provider.getNodes({ parentNode: undefined })).pipe(
-      expand((node) => (node.children ? provider.getNodes({ parentNode: node }) : EMPTY)),
-      mergeMap(async (node) => waitFor(async () => validateNodeVisibility({ ...props, node }))),
+      expand((node) => (node.children && (!ignoreChildren || !ignoreChildren(node)) ? provider.getNodes({ parentNode: node }) : EMPTY), 1000),
+      mergeMap(async (node) => waitFor(async () => validateNodeVisibility({ ...props, node })), 1000),
     ),
   );
 }

apps/performance-tests/src/util/TestReporter.cts

@@ -7,7 +7,9 @@ import asTable from "as-table";
 import fs from "fs";
 import Mocha from "mocha";
 import { LOGGER } from "./Logging.cjs";
-import { MainThreadBlocksDetector, Summary } from "./MainThreadBlocksDetector.cjs";
+import { MainThreadBlocksDetector } from "./MainThreadBlocksDetector.cjs";
+
+import type { Summary } from "./MainThreadBlocksDetector.cjs";
 
 interface TestInfo {
   test: Mocha.Runnable;

packages/itwin/tree-widget/src/test/trees/models-tree/internal/ModelsTreeVisibilityHandler.test.ts

@@ -2196,36 +2196,6 @@ describe("ModelsTreeVisibilityHandler", () => {
       });
     });
 
-    it.skip("validates visibility for large iModel", async function () {
-      await using buildIModelResult = await buildIModel(this, async (builder) => {
-        const modelsToTurnOn = new Array<string>();
-        let elementId = "";
-        for (let i = 0; i < 3; ++i) {
-          const model = insertPhysicalModelWithPartition({ builder, partitionParentId: IModel.rootSubjectId, codeValue: `model${i}` }).id;
-          modelsToTurnOn.push(model);
-          for (let j = 0; j < 1000; ++j) {
-            const categoryId = insertSpatialCategory({ builder, codeValue: `category${i}-${j}` }).id;
-            elementId = insertPhysicalElement({ builder, modelId: model, categoryId }).id;
-          }
-        }
-        return { modelsToTurnOn, elementId };
-      });
-
-      const { imodel, ...ids } = buildIModelResult;
-      using visibilityTestData = createVisibilityTestData({ imodel });
-      const { handler, provider, viewport } = visibilityTestData;
-      await Promise.all(ids.modelsToTurnOn.map(async (modelId) => handler.changeVisibility(createModelHierarchyNode(modelId), true)));
-      viewport.setAlwaysDrawn(new Set([ids.elementId]));
-      viewport.renderFrame();
-      await validateHierarchyVisibility({
-        provider,
-        handler,
-        viewport,
-        visibilityExpectations: VisibilityExpectations.all("visible"),
-        waitForOptions: { timeout: 2000 },
-      });
-    });
-
     it("showing model makes it, all its categories and elements visible and doesn't affect other models", async function () {
       await using buildIModelResult = await buildIModel(this, async (builder) => {
         const categoryId = insertSpatialCategory({ builder, codeValue: "category" }).id;