Add integration test

Author: JonasDov

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

@@ -9,8 +9,9 @@ import { IModel, IModelReadRpcInterface } from "@itwin/core-common";
 import { ECSchemaRpcInterface } from "@itwin/ecschema-rpcinterface-common";
 import { ECSchemaRpcImpl } from "@itwin/ecschema-rpcinterface-impl";
 import { PresentationRpcInterface } from "@itwin/presentation-common";
-import { HierarchyNodeIdentifier } from "@itwin/presentation-hierarchies";
+import { HierarchyFilteringPath, HierarchyNodeIdentifier } from "@itwin/presentation-hierarchies";
 import { HierarchyCacheMode, initialize as initializePresentationTesting, terminate as terminatePresentationTesting } from "@itwin/presentation-testing";
+import { joinHierarchyFilteringPaths } from "../../../tree-widget-react/components/trees/common/Utils.js";
 import { ModelsTreeIdsCache } from "../../../tree-widget-react/components/trees/models-tree/internal/ModelsTreeIdsCache.js";
 import { defaultHierarchyConfiguration, ModelsTreeDefinition } from "../../../tree-widget-react/components/trees/models-tree/ModelsTreeDefinition.js";
 import {
@@ -29,11 +30,9 @@ import { createClassGroupingHierarchyNode, createModelsTreeProvider } from "./Ut
 import type { Id64String } from "@itwin/core-bentley";
 import type { IModelConnection } from "@itwin/core-frontend";
 import type { InstanceKey } from "@itwin/presentation-common";
-import type { HierarchyFilteringPath } from "@itwin/presentation-hierarchies";
 import type { TestIModelBuilder } from "@itwin/presentation-testing";
 import type { ExpectedHierarchyDef } from "../HierarchyValidation.js";
 import type { ElementsGroupInfo } from "../../../tree-widget-react/components/trees/models-tree/ModelsTreeDefinition.js";
-
 type ModelsTreeHierarchyConfiguration = ConstructorParameters<typeof ModelsTreeDefinition>[0]["hierarchyConfig"];
 
 interface TreeFilteringTestCaseDefinition<TIModelSetupResult extends {}> {
@@ -100,6 +99,102 @@ describe("Models tree", () => {
       await terminatePresentationTesting();
     });
 
+    it("sets auto-expand on correct nodes with merged sub-tree and filter paths", async function () {
+      await using buildIModelResult = await buildIModel(this, async (builder) => {
+        const rootSubject: InstanceKey = { className: "BisCore.Subject", id: IModel.rootSubjectId };
+        const model = insertPhysicalModelWithPartition({ builder, codeValue: `model`, partitionParentId: rootSubject.id });
+        const category = insertSpatialCategory({ builder, codeValue: "category" });
+        const parentElement = insertPhysicalElement({
+          builder,
+          userLabel: `parent el`,
+          modelId: model.id,
+          categoryId: category.id,
+        });
+        const childElement = insertPhysicalElement({
+          builder,
+          userLabel: `child el`,
+          modelId: model.id,
+          categoryId: category.id,
+          parentId: parentElement.id,
+        });
+        insertPhysicalElement({
+          builder,
+          userLabel: `unrelated el`,
+          modelId: model.id,
+          categoryId: category.id,
+        });
+        return { rootSubject, model, category, parentElement, childElement };
+      });
+      const { imodel, ...keys } = buildIModelResult;
+      const imodelAccess = createIModelAccess(imodel);
+      const config = { ...defaultHierarchyConfiguration, hideRootSubject: true, elementClassSpecification: keys.parentElement.className };
+      using idsCache = new ModelsTreeIdsCache(imodelAccess, config);
+      const [subTreePaths, filterPaths] = await Promise.all([
+        ModelsTreeDefinition.createInstanceKeyPaths({
+          imodelAccess,
+          idsCache,
+          hierarchyConfig: config,
+          targetItems: [{ id: keys.childElement.id, className: keys.childElement.className }],
+        }),
+        ModelsTreeDefinition.createInstanceKeyPaths({ imodelAccess, idsCache, hierarchyConfig: config, label: "parent" }),
+      ]);
+      const joinedPaths = joinHierarchyFilteringPaths(
+        subTreePaths.map((path) => HierarchyFilteringPath.normalize(path).path),
+        filterPaths.map((path) => {
+          const normalizedPath = HierarchyFilteringPath.normalize(path);
+          normalizedPath.options = { autoExpand: true };
+          return normalizedPath;
+        }),
+      );
+
+      using provider = createModelsTreeProvider({
+        imodel,
+        hierarchyConfig: config,
+        filteredNodePaths: joinedPaths,
+        imodelAccess,
+        idsCache,
+      });
+      await validateHierarchy({
+        provider,
+        expect: [
+          NodeValidators.createForInstanceNode({
+            instanceKeys: [keys.model],
+            supportsFiltering: true,
+            autoExpand: true,
+            children: [
+              NodeValidators.createForInstanceNode({
+                instanceKeys: [keys.category],
+                supportsFiltering: true,
+                autoExpand: true,
+                children: [
+                  NodeValidators.createForClassGroupingNode({
+                    autoExpand: true,
+                    children: [
+                      NodeValidators.createForInstanceNode({
+                        instanceKeys: [keys.parentElement],
+                        supportsFiltering: true,
+                        children: [
+                          NodeValidators.createForClassGroupingNode({
+                            children: [
+                              NodeValidators.createForInstanceNode({
+                                instanceKeys: [keys.childElement],
+                                supportsFiltering: true,
+                                children: false,
+                              }),
+                            ],
+                          }),
+                        ],
+                      }),
+                    ],
+                  }),
+                ],
+              }),
+            ],
+          }),
+        ],
+      });
+    });
+
     runTestCases(
       TreeFilteringTestCaseDefinition.create(
         "immediate Subject nodes",

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

@@ -27,21 +27,25 @@ interface CreateModelsTreeProviderProps {
   imodel: IModelConnection;
   filteredNodePaths?: HierarchyFilteringPath[];
   hierarchyConfig?: Partial<ModelsTreeHierarchyConfiguration>;
+  idsCache?: ModelsTreeIdsCache;
+  imodelAccess?: ReturnType<typeof createIModelAccess>;
 }
 
 export function createModelsTreeProvider({
   imodel,
   filteredNodePaths,
   hierarchyConfig,
+  imodelAccess,
+  idsCache,
 }: CreateModelsTreeProviderProps): HierarchyProvider & { dispose: () => void; [Symbol.dispose]: () => void } {
   const config = { ...defaultHierarchyConfiguration, hideRootSubject: true, ...hierarchyConfig };
-  const imodelAccess = createIModelAccess(imodel);
-  const idsCache = new ModelsTreeIdsCache(imodelAccess, config);
+  const createdImodelAccess = imodelAccess ?? createIModelAccess(imodel);
+  const createdIdsCache = idsCache ?? new ModelsTreeIdsCache(createdImodelAccess, config);
   const provider = createIModelHierarchyProvider({
-    imodelAccess,
+    imodelAccess: createdImodelAccess,
     hierarchyDefinition: new ModelsTreeDefinition({
-      imodelAccess,
-      idsCache,
+      imodelAccess: createdImodelAccess,
+      idsCache: createdIdsCache,
       hierarchyConfig: config,
     }),
     ...(filteredNodePaths
@@ -50,7 +54,9 @@ export function createModelsTreeProvider({
   });
   const dispose = () => {
     provider[Symbol.dispose]();
-    idsCache[Symbol.dispose]();
+    if (!idsCache) {
+      createdIdsCache[Symbol.dispose]();
+    }
   };
   return {
     hierarchyChanged: provider.hierarchyChanged,

packages/itwin/tree-widget/src/tree-widget-react/components/trees/models-tree/ModelsTreeDefinition.ts

@@ -544,7 +544,7 @@ export class ModelsTreeDefinition implements HierarchyDefinition {
     ];
   }
 
-  public static async createInstanceKeyPaths(props: ModelsTreeInstanceKeyPathsProps) {
+  public static async createInstanceKeyPaths(props: ModelsTreeInstanceKeyPathsProps): Promise<HierarchyFilteringPath[]> {
     return lastValueFrom(
       defer(() => {
         if (ModelsTreeInstanceKeyPathsProps.isLabelProps(props)) {