@itwin/core-backend 5.4.0-dev.5 → 5.4.0-dev.7

package/lib/esm/test/hubaccess/Rebase.test.js

@@ -7,7 +7,7 @@ import { Code, IModel, QueryBinder, SubCategoryAppearance } from "@itwin/core-co
 import * as chai from "chai";
 import * as chaiAsPromised from "chai-as-promised";
 import { HubWrappers, IModelTestUtils, KnownTestLocations } from "..";
-import { BriefcaseManager, ChannelControl, DrawingCategory, IModelHost, SqliteChangesetReader } from "../../core-backend";
+import { BriefcaseManager, ChangesetECAdaptor, ChannelControl, DrawingCategory, IModelHost, SqliteChangesetReader } from "../../core-backend";
 import { HubMock } from "../../internal/HubMock";
 import { StashManager } from "../../StashManager";
 import { existsSync, unlinkSync, writeFileSync } from "fs";
@@ -739,6 +739,41 @@ describe("rebase changes & stashing api", function () {
         chai.expect(b2.elements.tryGetElementProps(e3)).to.undefined; // add by rebase so should not exist either
         chai.expect(BriefcaseManager.containsRestorePoint(b2, BriefcaseManager.PULL_MERGE_RESTORE_POINT_NAME)).is.false;
     });
+    it("calling discardChanges() from inside indirect scope is not allowed", async () => {
+        const b1 = await testIModel.openBriefcase();
+        await testIModel.insertElement(b1);
+        b1.saveChanges();
+        const p1 = b1.txns.withIndirectTxnModeAsync(async () => {
+            await b1.discardChanges();
+        });
+        await chai.expect(p1).to.be.rejectedWith("Cannot discard changes when there are indirect changes");
+        b1.saveChanges();
+    });
+    it("calling discardChanges() during rebasing is not allowed", async () => {
+        const b1 = await testIModel.openBriefcase();
+        const b2 = await testIModel.openBriefcase();
+        await testIModel.insertElement(b1);
+        await testIModel.insertElement(b1);
+        b1.saveChanges();
+        await b1.pushChanges({ description: "inserted element" });
+        await testIModel.insertElement(b2);
+        await testIModel.insertElement(b2);
+        b2.saveChanges();
+        b2.txns.rebaser.setCustomHandler({
+            shouldReinstate: (_txnProps) => {
+                return true;
+            },
+            recompute: async (_txnProps) => {
+                chai.expect(b2.txns.rebaser.isAborting).is.false;
+                await b2.discardChanges();
+            },
+        });
+        chai.expect(b2.txns.rebaser.isAborting).is.false;
+        const p1 = b2.pullChanges();
+        await chai.expect(p1).to.be.rejectedWith("Cannot discard changes while a rebase is in progress");
+        chai.expect(b2.txns.rebaser.canAbort()).is.true;
+        await b2.txns.rebaser.abort();
+    });
     it("getStash() should throw exception", async () => {
         const b1 = await testIModel.openBriefcase();
         chai.expect(() => StashManager.getStash({ db: b1, stash: "invalid_stash" })).to.throw("Invalid stash");
@@ -803,5 +838,154 @@ describe("rebase changes & stashing api", function () {
         const e3Props = await findElement(e3);
         chai.expect(e3Props).to.exist;
     });
+    it("enum txn changes in recompute", async () => {
+        const b1 = await testIModel.openBriefcase();
+        const b2 = await testIModel.openBriefcase();
+        const e1 = await testIModel.insertElement(b1);
+        const e2 = await testIModel.insertElement(b1, true);
+        b1.saveChanges();
+        await b1.pushChanges({ description: "insert element 1 direct and 1 indirect" });
+        await b2.pullChanges();
+        await testIModel.updateElement(b1, e1);
+        await testIModel.updateElement(b1, e2, true);
+        b1.saveChanges();
+        await b1.pushChanges({ description: "update element 1 direct and 1 indirect" });
+        await testIModel.insertElement(b2);
+        await testIModel.insertElement(b2, true);
+        b2.saveChanges("first change");
+        await testIModel.insertElement(b2);
+        await testIModel.insertElement(b2, true);
+        b2.saveChanges("second change");
+        await testIModel.insertElement(b2);
+        await testIModel.insertElement(b2, true);
+        b2.saveChanges("third change");
+        let txnVerified = 0;
+        b2.txns.rebaser.setCustomHandler({
+            shouldReinstate: (_txn) => {
+                return true;
+            },
+            recompute: async (txn) => {
+                const reader = SqliteChangesetReader.openTxn({ txnId: txn.id, db: b2, disableSchemaCheck: true });
+                const adaptor = new ChangesetECAdaptor(reader);
+                adaptor.acceptClass("TestDomain:a1");
+                const ids = new Set();
+                while (adaptor.step()) {
+                    if (!adaptor.reader.isIndirect)
+                        ids.add(adaptor.inserted?.ECInstanceId || adaptor.deleted?.ECInstanceId);
+                }
+                adaptor.close();
+                if (txn.props.description === "first change") {
+                    chai.expect(Array.from(ids.keys())).deep.equal(["0x40000000001"]);
+                    txnVerified++;
+                }
+                else if (txn.props.description === "second change") {
+                    chai.expect(Array.from(ids.keys())).deep.equal(["0x40000000003"]);
+                    txnVerified++;
+                }
+                else if (txn.props.description === "third change") {
+                    chai.expect(Array.from(ids.keys())).deep.equal(["0x40000000005"]);
+                    txnVerified++;
+                }
+                else {
+                    txnVerified++;
+                }
+            },
+        });
+        await b2.pullChanges();
+        chai.expect(txnVerified).to.equal(3);
+    });
+    it("before and after rebase events", async () => {
+        const b1 = await testIModel.openBriefcase();
+        const b2 = await testIModel.openBriefcase();
+        const e1 = await testIModel.insertElement(b1);
+        const e2 = await testIModel.insertElement(b1, true);
+        b1.saveChanges();
+        await b1.pushChanges({ description: "insert element 1 direct and 1 indirect" });
+        await b2.pullChanges();
+        await testIModel.updateElement(b1, e1);
+        await testIModel.updateElement(b1, e2, true);
+        b1.saveChanges();
+        await b1.pushChanges({ description: "update element 1 direct and 1 indirect" });
+        await testIModel.insertElement(b2);
+        await testIModel.insertElement(b2, true);
+        b2.saveChanges("first change");
+        await testIModel.insertElement(b2);
+        await testIModel.insertElement(b2, true);
+        b2.saveChanges("second change");
+        await testIModel.insertElement(b2);
+        await testIModel.insertElement(b2, true);
+        b2.saveChanges("third change");
+        const events = {
+            onRebase: {
+                beginCount: 0,
+                endCount: 0,
+                beginIds: [],
+            },
+            onRebaseTxn: {
+                beginTxns: [],
+                endTxns: [],
+            },
+            rebaseHandler: {
+                shouldReinstate: [],
+                recompute: [],
+            }
+        };
+        const resetEvent = () => {
+            events.onRebase.beginCount = 0;
+            events.onRebase.endCount = 0;
+            events.onRebase.beginIds = [];
+            events.onRebaseTxn.beginTxns = [];
+            events.onRebaseTxn.endTxns = [];
+            events.rebaseHandler.shouldReinstate = [];
+            events.rebaseHandler.recompute = [];
+        };
+        b2.txns.onRebaseBegin.addListener((ids) => {
+            events.onRebase.beginCount++;
+            events.onRebase.beginIds.push(...ids);
+        });
+        b2.txns.onRebaseEnd.addListener(() => {
+            events.onRebase.endCount++;
+        });
+        b2.txns.onRebaseTxnBegin.addListener((txn) => {
+            events.onRebaseTxn.beginTxns.push(txn);
+        });
+        b2.txns.onRebaseTxnEnd.addListener((txn) => {
+            events.onRebaseTxn.endTxns.push(txn);
+        });
+        b2.txns.rebaser.setCustomHandler({
+            shouldReinstate: (_txn) => {
+                events.rebaseHandler.shouldReinstate.push(_txn);
+                return true;
+            },
+            recompute: async (_txn) => {
+                events.rebaseHandler.recompute.push(_txn);
+            },
+        });
+        resetEvent();
+        await b2.pullChanges();
+        chai.expect(events.onRebase.beginCount).to.equal(1);
+        chai.expect(events.onRebase.endCount).to.equal(1);
+        chai.expect(events.onRebase.beginIds).to.deep.equal(["0x100000000", "0x100000001", "0x100000002"]);
+        chai.expect(events.onRebaseTxn.beginTxns.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002"]);
+        chai.expect(events.onRebaseTxn.endTxns.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002"]);
+        chai.expect(events.rebaseHandler.shouldReinstate.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002"]);
+        chai.expect(events.rebaseHandler.recompute.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002"]);
+        await testIModel.updateElement(b1, e1);
+        await testIModel.updateElement(b1, e2, true);
+        b1.saveChanges();
+        await b1.pushChanges({ description: "update element 1 direct and 1 indirect" });
+        await testIModel.insertElement(b2);
+        await testIModel.insertElement(b2, true);
+        b2.saveChanges("forth change");
+        resetEvent();
+        await b2.pullChanges();
+        chai.expect(events.onRebase.beginCount).to.equal(1);
+        chai.expect(events.onRebase.endCount).to.equal(1);
+        chai.expect(events.onRebase.beginIds).to.deep.equal(["0x100000000", "0x100000001", "0x100000002", "0x100000003"]);
+        chai.expect(events.onRebaseTxn.beginTxns.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002", "0x100000003"]);
+        chai.expect(events.onRebaseTxn.endTxns.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002", "0x100000003"]);
+        chai.expect(events.rebaseHandler.shouldReinstate.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002", "0x100000003"]);
+        chai.expect(events.rebaseHandler.recompute.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002", "0x100000003"]);
+    });
 });
 //# sourceMappingURL=Rebase.test.js.map