@itwin/core-backend 5.9.0-dev.4 → 5.9.0-dev.5

package/lib/esm/test/ElementDrivesElement.test.js

@@ -1,21 +1,24 @@
-import { BeEvent, DbResult, IModelStatus, StopWatch } from "@itwin/core-bentley";
+import { BeEvent, DbResult, Guid, IModelStatus, StopWatch } from "@itwin/core-bentley";
 import { Code, GeometryStreamBuilder, IModel, IModelError, RelatedElement } from "@itwin/core-common";
 import { LineSegment3d, Point3d, YawPitchRollAngles } from "@itwin/core-geometry";
 import * as chai from "chai";
 import * as chaiAsPromised from "chai-as-promised";
 import { SpatialCategory } from "../Category";
-import { ChannelControl } from "../ChannelControl";
 import { ClassRegistry } from "../ClassRegistry";
 import { GeometricElement3d, PhysicalPartition } from "../Element";
-import { IModelDb } from "../IModelDb";
-import { HubMock } from "../internal/HubMock";
+import { IModelDb, StandaloneDb } from "../IModelDb";
 import { PhysicalModel } from "../Model";
 import { SubjectOwnsPartitionElements } from "../NavigationRelationship";
 import { ElementDrivesElement } from "../Relationship";
 import { Schema, Schemas } from "../Schema";
-import { HubWrappers } from "./IModelTestUtils";
-import { KnownTestLocations } from "./KnownTestLocations";
+import { EditTxn } from "../EditTxn";
+import { IModelTestUtils } from "./IModelTestUtils";
 chai.use(chaiAsPromised);
+function startTestTxn(iModelDb) {
+    const txn = new EditTxn(iModelDb, "element drives element test");
+    txn.start();
+    return txn;
+}
 /**
   1. What is Change Propagation?**
     In engineering, models often consist of many interdependent components (e.g., parts, assemblies, constraints). When you modify one component (say, changing a dimension), that change can affect other components.
@@ -237,10 +240,10 @@ class ElementDrivesElementEventMonitor {
     onDeletedDependency = [];
     constructor(iModelDb) {
         this.iModelDb = iModelDb;
-        InputDrivesOutput.events.onDeletedDependency.addListener((props) => this.onDeletedDependency.push([this.iModelDb.elements.tryGetElement(props.sourceId)?.userLabel, this.iModelDb.elements.tryGetElement(props.targetId)?.userLabel]));
-        InputDrivesOutput.events.onRootChanged.addListener((props) => this.onRootChanged.push([this.iModelDb.elements.tryGetElement(props.sourceId)?.userLabel, this.iModelDb.elements.tryGetElement(props.targetId)?.userLabel]));
-        NodeElement.events.onAllInputsHandled.addListener((id) => this.onAllInputsHandled.push(this.iModelDb.elements.tryGetElement(id)?.userLabel));
-        NodeElement.events.onBeforeOutputsHandled.addListener((id) => this.onBeforeOutputsHandled.push(this.iModelDb.elements.tryGetElement(id)?.userLabel));
+        InputDrivesOutput.events.onDeletedDependency.addListener((arg) => this.onDeletedDependency.push([this.iModelDb.elements.tryGetElement(arg.props.sourceId)?.userLabel, this.iModelDb.elements.tryGetElement(arg.props.targetId)?.userLabel]));
+        InputDrivesOutput.events.onRootChanged.addListener((arg) => this.onRootChanged.push([this.iModelDb.elements.tryGetElement(arg.props.sourceId)?.userLabel, this.iModelDb.elements.tryGetElement(arg.props.targetId)?.userLabel]));
+        NodeElement.events.onAllInputsHandled.addListener((arg) => this.onAllInputsHandled.push(this.iModelDb.elements.tryGetElement(arg.elId)?.userLabel));
+        NodeElement.events.onBeforeOutputsHandled.addListener((arg) => this.onBeforeOutputsHandled.push(this.iModelDb.elements.tryGetElement(arg.elId)?.userLabel));
     }
     clear() {
         this.onRootChanged.length = 0;
@@ -258,11 +261,11 @@ export class InputDrivesOutput extends ElementDrivesElement {
     constructor(props, iModel) {
         super(props, iModel);
     }
-    static onRootChanged(props, iModel) {
-        this.events.onRootChanged.raiseEvent(props, iModel);
+    static onRootChangedArg(arg) {
+        this.events.onRootChanged.raiseEvent(arg);
     }
-    static onDeletedDependency(props, iModel) {
-        this.events.onDeletedDependency.raiseEvent(props, iModel);
+    static onDeletedDependencyArg(arg) {
+        this.events.onDeletedDependency.raiseEvent(arg);
     }
 }
 export class NodeElement extends GeometricElement3d {
@@ -284,11 +287,11 @@ export class NodeElement extends GeometricElement3d {
         val.val = this.val;
         return val;
     }
-    static onAllInputsHandled(id, iModel) {
-        this.events.onAllInputsHandled.raiseEvent(id, iModel);
+    static onAllInputsHandledArg(arg) {
+        this.events.onAllInputsHandled.raiseEvent(arg);
     }
-    static onBeforeOutputsHandled(id, iModel) {
-        this.events.onBeforeOutputsHandled.raiseEvent(id, iModel);
+    static onBeforeOutputsHandledArg(arg) {
+        this.events.onBeforeOutputsHandled.raiseEvent(arg);
     }
     static generateGeometry(radius) {
         const builder = new GeometryStreamBuilder();
@@ -340,17 +343,17 @@ export class NetworkSchema extends Schema {
     }
 }
 export class Engine {
-    static async createGraph(iModelDb, modelId, graph) {
+    static async createGraph(txn, modelId, graph) {
         const nodes = new Map();
         const outGraph = new Graph();
         for (const node of graph.nodes()) {
-            const id = await this.insertNode(iModelDb, modelId, node, "", 0, new Point3d(0, 0, 0));
+            const id = await this.insertNode(txn, modelId, node, "", 0, new Point3d(0, 0, 0));
             nodes.set(node, { id, name: node });
         }
         for (const edge of graph.edges()) {
             const fromId = nodes.get(edge.from).id;
             const toId = nodes.get(edge.to).id;
-            await this.insertEdge(iModelDb, fromId, toId, 0);
+            await this.insertEdge(txn, fromId, toId, 0);
             outGraph.addEdge(nodes.get(edge.from), nodes.get(edge.to));
         }
         return outGraph;
@@ -411,7 +414,8 @@ export class Engine {
         });
         return edges;
     }
-    static async createPartition(iModelDb) {
+    static async createPartition(txn) {
+        const iModelDb = txn.iModel;
         const parentId = new SubjectOwnsPartitionElements(IModel.rootSubjectId);
         const modelId = IModel.repositoryModelId;
         const modeledElementProps = {
@@ -423,30 +427,33 @@ export class Engine {
         };
         const modeledElement = iModelDb.elements.createElement(modeledElementProps);
         await iModelDb.locks.acquireLocks({ shared: modelId });
-        return iModelDb.elements.insertElement(modeledElement.toJSON());
+        return txn.insertElement(modeledElement.toJSON());
     }
-    static async createModel(iModelDb) {
-        const partitionId = await this.createPartition(iModelDb);
+    static async createModel(txn) {
+        const iModelDb = txn.iModel;
+        const partitionId = await this.createPartition(txn);
         const modeledElementRef = new RelatedElement({ id: partitionId });
         const newModel = iModelDb.models.createModel({ modeledElement: modeledElementRef, classFullName: PhysicalModel.classFullName });
-        const newModelId = newModel.insert();
+        const newModelId = txn.insertModel(newModel.toJSON());
         return newModelId;
     }
-    static async createNodeCategory(iModelDb) {
+    static async createNodeCategory(txn) {
+        const iModelDb = txn.iModel;
         const category = SpatialCategory.create(iModelDb, IModelDb.dictionaryId, NodeElement.classFullName);
-        return category.insert();
+        return txn.insertElement(category.toJSON());
     }
-    static async initialize(iModelDb) {
-        await NetworkSchema.importSchema(iModelDb);
+    static async initialize(txn) {
+        await NetworkSchema.importSchema(txn.iModel);
         NetworkSchema.registerSchema();
-        const modelId = await this.createModel(iModelDb);
-        const categoryId = await this.createNodeCategory(iModelDb);
+        const modelId = await this.createModel(txn);
+        const categoryId = await this.createNodeCategory(txn);
         return {
             modelId,
             categoryId,
         };
     }
-    static async insertNode(iModelDb, modelId, name, op, val, location, radius = 0.1) {
+    static async insertNode(txn, modelId, name, op, val, location, radius = 0.1) {
+        const iModelDb = txn.iModel;
         const props = {
             classFullName: NodeElement.classFullName,
             model: modelId,
@@ -459,17 +466,20 @@ export class Engine {
             val,
         };
         await iModelDb.locks.acquireLocks({ shared: modelId });
-        return iModelDb.elements.insertElement(props);
+        return txn.insertElement(props);
     }
-    static async deleteNode(iModelDb, nodeId) {
+    static async deleteNode(txn, nodeId) {
+        const iModelDb = txn.iModel;
         await iModelDb.locks.acquireLocks({ exclusive: nodeId });
-        return iModelDb.elements.deleteElement(nodeId);
+        return txn.deleteElement(nodeId);
     }
-    static async updateNodeProps(iModelDb, props) {
+    static async updateNodeProps(txn, props) {
+        const iModelDb = txn.iModel;
         await iModelDb.locks.acquireLocks({ exclusive: props.id });
-        return iModelDb.elements.updateElement(props);
+        return txn.updateElement(props);
     }
-    static async updateNode(iModelDb, userLabel) {
+    static async updateNode(txn, userLabel) {
+        const iModelDb = txn.iModel;
         // eslint-disable-next-line @typescript-eslint/no-deprecated
         const id = iModelDb.withPreparedStatement("SELECT [ECInstanceId] FROM [Network].[Node] WHERE [UserLabel] = ?", (stmt) => {
             stmt.bindString(1, userLabel);
@@ -480,9 +490,10 @@ export class Engine {
         if (!id) {
             throw new Error(`Node with userLabel ${userLabel} not found`);
         }
-        await this.updateNodeProps(iModelDb, { id });
+        await this.updateNodeProps(txn, { id });
     }
-    static async deleteEdge(iModelDb, from, to) {
+    static async deleteEdge(txn, from, to) {
+        const iModelDb = txn.iModel;
         // eslint-disable-next-line @typescript-eslint/no-deprecated
         const edge = iModelDb.withPreparedStatement(`
       SELECT [IDo].[ECInstanceId], [IDo].[SourceECInstanceId], [IDo].[TargetECInstanceId]
@@ -504,9 +515,9 @@ export class Engine {
         if (!edge) {
             throw new Error(`Edge from ${from} to ${to} not found`);
         }
-        iModelDb.relationships.deleteInstance(edge);
+        txn.deleteRelationship(edge);
     }
-    static async insertEdge(iModelDb, sourceId, targetId, prop) {
+    static async insertEdge(txn, sourceId, targetId, prop) {
         const props = {
             classFullName: InputDrivesOutput.classFullName,
             sourceId,
@@ -515,32 +526,31 @@ export class Engine {
             status: 0,
             priority: 0
         };
-        return iModelDb.relationships.insertInstance(props);
+        return txn.insertRelationship(props);
     }
 }
 describe("ElementDrivesElement Tests", () => {
-    const briefcases = [];
-    let iModelId;
-    async function openBriefcase() {
-        const iModelDb = await HubWrappers.downloadAndOpenBriefcase({ iTwinId: HubMock.iTwinId, iModelId });
-        iModelDb.channels.addAllowedChannel(ChannelControl.sharedChannelName);
-        iModelDb.saveChanges();
-        briefcases.push(iModelDb);
+    const iModels = [];
+    let testTxn;
+    async function openIModel() {
+        const iModelDb = StandaloneDb.createEmpty(IModelTestUtils.prepareOutputFile("ElementDrivesElement", `${Guid.createValue()}.bim`), { rootSubject: { name: "ElementDrivesElementTest" }, enableTransactions: true });
+        const txn = new EditTxn(iModelDb, "open iModel initialization");
+        txn.start();
+        txn.end();
+        iModels.push(iModelDb);
         return iModelDb;
     }
-    beforeEach(async () => {
-        HubMock.startup("TestIModel", KnownTestLocations.outputDir);
-        iModelId = await HubMock.createNewIModel({ iTwinId: HubMock.iTwinId, iModelName: "Test", description: "TestSubject" });
-    });
     afterEach(async () => {
         NodeElement.events.onAllInputsHandled.clear();
         NodeElement.events.onBeforeOutputsHandled.clear();
         InputDrivesOutput.events.onRootChanged.clear();
         InputDrivesOutput.events.onDeletedDependency.clear();
-        for (const briefcase of briefcases) {
-            briefcase.close();
-        }
-        HubMock.shutdown();
+        if (testTxn?.isActive)
+            testTxn.end("abandon");
+        testTxn = undefined;
+        for (const iModel of iModels)
+            iModel.close();
+        iModels.length = 0;
     });
     it("local: topological sort", async () => {
         const graph = new Graph();
@@ -607,12 +617,12 @@ describe("ElementDrivesElement Tests", () => {
         graph.addEdge("util.o", ["app.exe", "test.exe"]);
         graph.addEdge("config.json", ["app.exe", "test.exe"]);
         // create graph
-        const b1 = await openBriefcase();
-        const { modelId, } = await Engine.initialize(b1);
+        const b1 = await openIModel();
+        const txn = testTxn = startTestTxn(b1);
+        const { modelId, } = await Engine.initialize(txn);
         const monitor = new ElementDrivesElementEventMonitor(b1);
-        await Engine.createGraph(b1, modelId, graph);
-        b1.saveChanges();
-        b1.saveChanges();
+        await Engine.createGraph(txn, modelId, graph);
+        txn.saveChanges();
         chai.expect(monitor.onRootChanged).to.deep.equal([
             ["main.c", "main.o"],
             ["main.o", "test.exe"],
@@ -629,8 +639,8 @@ describe("ElementDrivesElement Tests", () => {
         chai.expect(monitor.onDeletedDependency).to.deep.equal([]);
         // update main.c
         monitor.clear();
-        await Engine.updateNode(b1, "main.c");
-        b1.saveChanges();
+        await Engine.updateNode(txn, "main.c");
+        txn.saveChanges();
         chai.expect(monitor.onRootChanged).to.deep.equal([
             ["main.c", "main.o"],
             ["main.o", "test.exe"],
@@ -668,11 +678,12 @@ describe("ElementDrivesElement Tests", () => {
         graph.addEdge("Belt", ["Jacket"]);
         graph.addNode("Watch");
         // Test using EDE
-        const b1 = await openBriefcase();
-        const { modelId, } = await Engine.initialize(b1);
+        const b1 = await openIModel();
+        const txn = testTxn = startTestTxn(b1);
+        const { modelId, } = await Engine.initialize(txn);
         const monitor = new ElementDrivesElementEventMonitor(b1);
-        await Engine.createGraph(b1, modelId, graph);
-        b1.saveChanges();
+        await Engine.createGraph(txn, modelId, graph);
+        txn.saveChanges();
         chai.expect(monitor.onRootChanged).to.deep.equal([
             ["Socks", "Shoes"],
             ["Underwear", "Shoes"],
@@ -689,8 +700,8 @@ describe("ElementDrivesElement Tests", () => {
         chai.expect(monitor.onBeforeOutputsHandled).to.deep.equal(["Socks", "Underwear", "Shirt"]);
         chai.expect(monitor.onDeletedDependency).to.deep.equal([]);
         monitor.clear();
-        await Engine.updateNode(b1, "Socks");
-        b1.saveChanges();
+        await Engine.updateNode(txn, "Socks");
+        txn.saveChanges();
         chai.expect(monitor.onRootChanged).to.deep.equal([["Socks", "Shoes"]]);
         chai.expect(monitor.onAllInputsHandled).to.deep.equal(["Shoes"]);
         chai.expect(monitor.onBeforeOutputsHandled).to.deep.equal(["Socks"]);
@@ -717,8 +728,9 @@ describe("ElementDrivesElement Tests", () => {
         chai.expect(sorted8).to.deep.equal(["Watch"]);
     });
     it("EDE: basic graph operations", async () => {
-        const b1 = await openBriefcase();
-        const { modelId, } = await Engine.initialize(b1);
+        const b1 = await openIModel();
+        const txn = testTxn = startTestTxn(b1);
+        const { modelId, } = await Engine.initialize(txn);
         const graph = new Graph();
         // Graph structure:
         //   A
@@ -726,15 +738,15 @@ describe("ElementDrivesElement Tests", () => {
         // B   C
         // |\  /
         // | \/
-        // E--D  
+        // E--D
         graph.addEdge("A", ["B", "C"]);
         graph.addEdge("B", ["E", "D"]);
         graph.addEdge("C", ["D"]);
         graph.addEdge("D", ["E"]);
         const monitor = new ElementDrivesElementEventMonitor(b1);
         // create a network
-        await Engine.createGraph(b1, modelId, graph);
-        b1.saveChanges();
+        await Engine.createGraph(txn, modelId, graph);
+        txn.saveChanges();
         chai.expect(monitor.onRootChanged).to.deep.equal([
             ["A", "B"],
             ["A", "C"],
@@ -748,8 +760,8 @@ describe("ElementDrivesElement Tests", () => {
         chai.expect(monitor.onDeletedDependency).to.deep.equal([]);
         monitor.clear();
         // update a node in network
-        await Engine.updateNode(b1, "B");
-        b1.saveChanges();
+        await Engine.updateNode(txn, "B");
+        txn.saveChanges();
         chai.expect(monitor.onRootChanged).to.deep.equal([
             ["B", "E"],
             ["B", "D"],
@@ -760,16 +772,17 @@ describe("ElementDrivesElement Tests", () => {
         chai.expect(monitor.onDeletedDependency).to.deep.equal([]);
         monitor.clear();
         // delete edge in network
-        await Engine.deleteEdge(b1, "B", "E");
-        b1.saveChanges();
+        await Engine.deleteEdge(txn, "B", "E");
+        txn.saveChanges();
         chai.expect(monitor.onRootChanged).to.deep.equal([]);
         chai.expect(monitor.onAllInputsHandled).to.deep.equal([]);
         chai.expect(monitor.onBeforeOutputsHandled).to.deep.equal([]);
         chai.expect(monitor.onDeletedDependency).to.deep.equal([["B", "E"]]);
     });
     it("EDE: cyclical throw exception", async () => {
-        const b1 = await openBriefcase();
-        const { modelId, } = await Engine.initialize(b1);
+        const b1 = await openIModel();
+        const txn = testTxn = startTestTxn(b1);
+        const { modelId, } = await Engine.initialize(txn);
         const graph = new Graph();
         // Graph structure with a cycle:
         //   A
@@ -780,9 +793,9 @@ describe("ElementDrivesElement Tests", () => {
         graph.addEdge("C", ["A"]);
         const monitor = new ElementDrivesElementEventMonitor(b1);
         // create a network
-        await Engine.createGraph(b1, modelId, graph);
-        chai.expect(() => b1.saveChanges()).to.throw("Could not save changes due to propagation failure.");
-        b1.abandonChanges();
+        await Engine.createGraph(txn, modelId, graph);
+        chai.expect(() => txn.saveChanges()).to.throw("Could not save changes due to propagation failure.");
+        txn.end("abandon");
         chai.expect(monitor.onRootChanged).to.deep.equal([["B", "C"], ["C", "A"], ["A", "B"]]);
         chai.expect(monitor.onAllInputsHandled).to.deep.equal(["C", "A", "B"]);
         chai.expect(monitor.onBeforeOutputsHandled).to.deep.equal([]);
@@ -790,8 +803,9 @@ describe("ElementDrivesElement Tests", () => {
         monitor.clear();
     });
     it("EDE: cyclical graph can start propagation with no clear starting element", async () => {
-        const b1 = await openBriefcase();
-        const { modelId, } = await Engine.initialize(b1);
+        const b1 = await openIModel();
+        const txn = testTxn = startTestTxn(b1);
+        const { modelId, } = await Engine.initialize(txn);
         const graph = new Graph();
         // Graph structure with a cycle:
         //   A
@@ -806,9 +820,9 @@ describe("ElementDrivesElement Tests", () => {
         graph.addEdge("C", ["A"]);
         const monitor = new ElementDrivesElementEventMonitor(b1);
         // create a network
-        await Engine.createGraph(b1, modelId, graph);
-        chai.expect(() => b1.saveChanges()).to.throw("Could not save changes due to propagation failure.");
-        b1.abandonChanges();
+        await Engine.createGraph(txn, modelId, graph);
+        chai.expect(() => txn.saveChanges()).to.throw("Could not save changes due to propagation failure.");
+        txn.end("abandon");
         chai.expect(monitor.onRootChanged).to.deep.equal([["C", "A"], ["A", "B"], ["B", "C"]]);
         chai.expect(monitor.onAllInputsHandled).to.deep.equal(["A", "B", "C"]);
         chai.expect(monitor.onBeforeOutputsHandled).to.deep.equal([]);
@@ -816,8 +830,9 @@ describe("ElementDrivesElement Tests", () => {
         monitor.clear();
     });
     it.skip("EDE: performance", async () => {
-        const b1 = await openBriefcase();
-        const { modelId, } = await Engine.initialize(b1);
+        const b1 = await openIModel();
+        const txn = testTxn = startTestTxn(b1);
+        const { modelId, } = await Engine.initialize(txn);
         const graph = new Graph();
         const createTree = (depth, breadth, prefix) => {
             if (depth === 0)
@@ -836,7 +851,7 @@ describe("ElementDrivesElement Tests", () => {
         };
         const stopWatch0 = new StopWatch("create graph", true);
         createTree(5, 3, "N");
-        await Engine.createGraph(b1, modelId, graph);
+        await Engine.createGraph(txn, modelId, graph);
         stopWatch0.stop();
         const createGraphTime = stopWatch0.elapsed.seconds;
         let onRootChangedCount = 0;
@@ -845,10 +860,10 @@ describe("ElementDrivesElement Tests", () => {
         let onBeforeOutputsHandledCount = 0;
         InputDrivesOutput.events.onRootChanged.addListener(() => { onRootChangedCount++; });
         InputDrivesOutput.events.onDeletedDependency.addListener(() => { onDeletedDependencyCount++; });
-        NodeElement.events.onAllInputsHandled.addListener((_id) => { onAllInputsHandledCount++; });
+        NodeElement.events.onAllInputsHandled.addListener(() => { onAllInputsHandledCount++; });
         NodeElement.events.onBeforeOutputsHandled.addListener(() => { onBeforeOutputsHandledCount++; });
         const stopWatch1 = new StopWatch("save changes", true);
-        b1.saveChanges();
+        txn.saveChanges();
         stopWatch1.stop();
         const saveChangesTime = stopWatch1.elapsed.seconds;
         chai.expect(onRootChangedCount).to.be.equals(7380);