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

package/lib/esm/test/annotations/TextAnnotation.test.js

@@ -20,6 +20,7 @@ import { TextAnnotationUsesTextStyleByDefault } from "../../annotations/ElementD
 import { layoutTextBlock, TextStyleResolver } from "../../annotations/TextBlockLayout";
 import { appendTextAnnotationGeometry } from "../../annotations/TextAnnotationGeometry";
 import { IModelElementCloneContext } from "../../IModelElementCloneContext";
+import { EditTxn, withEditTxn } from "../../EditTxn";
 import * as fs from "fs";
 function mockIModel() {
     const iModel = {
@@ -51,23 +52,23 @@ const createJobSubjectElement = (iModel, name) => {
     subj.setJsonProperty("Subject", { Job: name }); // eslint-disable-line @typescript-eslint/naming-convention
     return subj;
 };
-const insertDrawingModel = (standaloneModel, parentId, definitionModel) => {
-    const category = DrawingCategory.insert(standaloneModel, definitionModel, "DrawingCategory", new SubCategoryAppearance());
-    const [_, model] = IModelTestUtils.createAndInsertDrawingPartitionAndModel(standaloneModel, { spec: '0x1', scope: '0x1', value: 'Drawing' }, undefined, parentId);
-    const displayStyle = DisplayStyle2d.insert(standaloneModel, definitionModel, "DisplayStyle2d");
-    const categorySelector = CategorySelector.insert(standaloneModel, definitionModel, "DrawingCategories", [category]);
+const insertDrawingModel = (txn, parentId, definitionModel) => {
+    const category = DrawingCategory.insert(txn, definitionModel, "DrawingCategory", new SubCategoryAppearance());
+    const [_, model] = IModelTestUtils.createAndInsertDrawingPartitionAndModel(txn, { spec: '0x1', scope: '0x1', value: 'Drawing' }, undefined, parentId);
+    const displayStyle = DisplayStyle2d.insert(txn, definitionModel, "DisplayStyle2d");
+    const categorySelector = CategorySelector.insert(txn, definitionModel, "DrawingCategories", [category]);
     const viewRange = new Range2d(0, 0, 500, 500);
-    DrawingViewDefinition.insert(standaloneModel, definitionModel, "Drawing View", model, categorySelector, displayStyle, viewRange);
+    DrawingViewDefinition.insert(txn, definitionModel, "Drawing View", model, categorySelector, displayStyle, viewRange);
     return { category, model };
 };
-const insertSpatialModel = (standaloneModel, parentId, definitionModel) => {
-    const category = SpatialCategory.insert(standaloneModel, definitionModel, "spatialCategory", new SubCategoryAppearance());
-    const [_, model] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(standaloneModel, { spec: '0x1', scope: '0x1', value: 'Spatial' }, undefined, parentId);
-    const modelSelector = ModelSelector.insert(standaloneModel, definitionModel, "SpatialModelSelector", [model]);
-    const displayStyle = DisplayStyle3d.insert(standaloneModel, definitionModel, "DisplayStyle3d");
-    const categorySelector = CategorySelector.insert(standaloneModel, definitionModel, "spatialCategories", [category]);
+const insertSpatialModel = (txn, parentId, definitionModel) => {
+    const category = SpatialCategory.insert(txn, definitionModel, "spatialCategory", new SubCategoryAppearance());
+    const [_, model] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(txn, { spec: '0x1', scope: '0x1', value: 'Spatial' }, undefined, parentId);
+    const modelSelector = ModelSelector.insert(txn, definitionModel, "SpatialModelSelector", [model]);
+    const displayStyle = DisplayStyle3d.insert(txn, definitionModel, "DisplayStyle3d");
+    const categorySelector = CategorySelector.insert(txn, definitionModel, "spatialCategories", [category]);
     const viewRange = new Range3d(0, 0, 0, 500, 500, 500);
-    SpatialViewDefinition.insertWithCamera(standaloneModel, definitionModel, "spatial View", modelSelector, categorySelector, displayStyle, viewRange);
+    SpatialViewDefinition.insertWithCamera(txn, definitionModel, "spatial View", modelSelector, categorySelector, displayStyle, viewRange);
     return { category, model };
 };
 const createIModel = async (name) => {
@@ -79,8 +80,10 @@ const createIModel = async (name) => {
         projectExtents: { low: { x: -500, y: -500, z: -50 }, high: { x: 500, y: 500, z: 50 } },
         guid: Guid.createValue(),
     });
-    await iModel.fonts.embedFontFile({
-        file: FontFile.createFromTrueTypeFileName(IModelTestUtils.resolveFontFile("Karla-Regular.ttf"))
+    await withEditTxn(iModel, async () => {
+        await iModel.fonts.embedFontFile({
+            file: FontFile.createFromTrueTypeFileName(IModelTestUtils.resolveFontFile("Karla-Regular.ttf"))
+        });
     });
     return iModel;
 };
@@ -271,10 +274,17 @@ describe("TextAnnotation element", () => {
         let createElement3dArgs;
         before(async () => {
             imodel = await createIModel("TextAnnotation3d");
-            const jobSubjectId = createJobSubjectElement(imodel, "Job").insert();
-            const definitionModel = DefinitionModel.insert(imodel, jobSubjectId, "Definition");
-            const { category, model } = insertSpatialModel(imodel, jobSubjectId, definitionModel);
-            const styleId = createAnnotationTextStyle(imodel, definitionModel, "test", { font: { name: "Totally Real Font" }, textHeight: 0.25, isItalic: true }).insert();
+            let jobSubjectId;
+            let definitionModel;
+            let category;
+            let model;
+            let styleId;
+            withEditTxn(imodel, (txn) => {
+                jobSubjectId = createJobSubjectElement(imodel, "Job").insert(txn);
+                definitionModel = DefinitionModel.insert(txn, jobSubjectId, "Definition");
+                ({ category, model } = insertSpatialModel(txn, jobSubjectId, definitionModel));
+                styleId = createAnnotationTextStyle(imodel, definitionModel, "test", { font: { name: "Totally Real Font" }, textHeight: 0.25, isItalic: true }).insert(txn);
+            });
             expect(jobSubjectId).not.to.be.undefined;
             expect(category).not.to.be.undefined;
             expect(model).not.to.be.undefined;
@@ -305,7 +315,7 @@ describe("TextAnnotation element", () => {
                     el0.setAnnotation(annotation);
                 }
                 expectPlacement3d(el0, false);
-                const elId = el0.insert();
+                const elId = withEditTxn(imodel, (txn) => el0.insert(txn));
                 expect(Id64.isValidId64(elId)).to.be.true;
                 const el1 = imodel.elements.getElement(elId);
                 expect(el1).not.to.be.undefined;
@@ -331,18 +341,21 @@ describe("TextAnnotation element", () => {
         let createElement2dArgs;
         before(async () => {
             imodel = await createIModel("TextAnnotation2d");
-            const jobSubjectId = createJobSubjectElement(imodel, "Job").insert();
-            const definitionModel = DefinitionModel.insert(imodel, jobSubjectId, "Definition");
-            const { category, model } = insertDrawingModel(imodel, jobSubjectId, definitionModel);
+            let jobSubjectId;
+            let definitionModel;
+            let category;
+            let model;
+            withEditTxn(imodel, (txn) => {
+                jobSubjectId = createJobSubjectElement(imodel, "Job").insert(txn);
+                definitionModel = DefinitionModel.insert(txn, jobSubjectId, "Definition");
+                ({ category, model } = insertDrawingModel(txn, jobSubjectId, definitionModel));
+            });
             expect(jobSubjectId).not.to.be.undefined;
             expect(category).not.to.be.undefined;
             expect(model).not.to.be.undefined;
             createElement2dArgs = { category, model };
         });
-        after(() => {
-            imodel.saveChanges("tests");
-            imodel.close();
-        });
+        after(() => imodel.close());
         it("creating element does not automatically compute the geometry", () => {
             const annotation = createAnnotation();
             const args = { ...createElement2dArgs, textAnnotationProps: annotation.toJSON() };
@@ -363,7 +376,7 @@ describe("TextAnnotation element", () => {
                     el0.setAnnotation(annotation);
                 }
                 expectPlacement2d(el0, false);
-                const elId = el0.insert();
+                const elId = withEditTxn(imodel, (txn) => el0.insert(txn));
                 expect(Id64.isValidId64(elId)).to.be.true;
                 const el1 = imodel.elements.getElement(elId);
                 expect(el1).not.to.be.undefined;
@@ -393,10 +406,16 @@ describe("TextAnnotation element", () => {
         let seedStyleId2;
         before(async () => {
             imodel = await createIModel("DefaultTextStyle");
-            const jobSubjectId = createJobSubjectElement(imodel, "Job").insert();
-            const definitionModel = DefinitionModel.insert(imodel, jobSubjectId, "Definition");
-            const styleId = createAnnotationTextStyle(imodel, definitionModel, "test", { font: { name: "Totally Real Font" }, textHeight: 0.25, isItalic: true }).insert();
-            const differentStyleId = createAnnotationTextStyle(imodel, definitionModel, "alt", { font: { name: "Karla" }, textHeight: 0.5, isBold: true }).insert();
+            let jobSubjectId;
+            let definitionModel;
+            let styleId;
+            let differentStyleId;
+            withEditTxn(imodel, (txn) => {
+                jobSubjectId = createJobSubjectElement(imodel, "Job").insert(txn);
+                definitionModel = DefinitionModel.insert(txn, jobSubjectId, "Definition");
+                styleId = createAnnotationTextStyle(imodel, definitionModel, "test", { font: { name: "Totally Real Font" }, textHeight: 0.25, isItalic: true }).insert(txn);
+                differentStyleId = createAnnotationTextStyle(imodel, definitionModel, "alt", { font: { name: "Karla" }, textHeight: 0.5, isBold: true }).insert(txn);
+            });
             expect(jobSubjectId).not.to.be.undefined;
             expect(definitionModel).not.to.be.undefined;
             expect(styleId).not.to.be.undefined;
@@ -406,14 +425,15 @@ describe("TextAnnotation element", () => {
             seedStyleId = styleId;
             seedStyleId2 = differentStyleId;
         });
-        after(() => {
-            imodel.saveChanges("tests");
-            imodel.close();
-        });
+        after(() => imodel.close());
         describe("TextAnnotation2d", () => {
             let createElement2dArgs;
             before(() => {
-                const { category, model } = insertDrawingModel(imodel, seedSubjectId, seedDefinitionModelId);
+                let category;
+                let model;
+                withEditTxn(imodel, (txn) => {
+                    ({ category, model } = insertDrawingModel(txn, seedSubjectId, seedDefinitionModelId));
+                });
                 expect(category).not.to.be.undefined;
                 expect(model).not.to.be.undefined;
                 createElement2dArgs = { category, model };
@@ -424,7 +444,7 @@ describe("TextAnnotation element", () => {
                 const el0 = createElement2d(imodel, args);
                 expect(el0.defaultTextStyle).not.to.be.undefined;
                 expect(el0.defaultTextStyle.id).to.equal(seedStyleId);
-                el0.insert();
+                withEditTxn(imodel, (txn) => el0.insert(txn));
                 const el1 = imodel.elements.getElement(el0.id);
                 expect(el1).not.to.be.undefined;
                 expect(el1.defaultTextStyle).not.to.be.undefined;
@@ -446,7 +466,7 @@ describe("TextAnnotation element", () => {
                 const args = { ...createElement2dArgs, textAnnotationProps: annotation.toJSON() };
                 const el0 = createElement2d(imodel, args);
                 el0.defaultTextStyle = undefined;
-                const elId = el0.insert();
+                const elId = withEditTxn(imodel, (txn) => el0.insert(txn));
                 expect(Id64.isValidId64(elId)).to.be.true;
                 const el1 = imodel.elements.getElement(elId);
                 expect(el1).not.to.be.undefined;
@@ -456,10 +476,11 @@ describe("TextAnnotation element", () => {
             describe("onCloned", () => {
                 function insertStyledElement(styleId, db) {
                     const args = { ...createElement2dArgs, defaultTextStyleId: styleId };
-                    const elem = createElement2d(db, args);
-                    elem.insert();
-                    imodel.saveChanges();
-                    return elem;
+                    return withEditTxn(db, (txn) => {
+                        const elem = createElement2d(db, args);
+                        elem.insert(txn);
+                        return elem;
+                    });
                 }
                 describe("within a single iModel", () => {
                     it("leaves property hosts intact", async () => {
@@ -487,8 +508,7 @@ describe("TextAnnotation element", () => {
                         });
                         const annotation = TextAnnotation.create({ textBlock, });
                         const elem = createElement2d(imodel, { ...createElement2dArgs, textAnnotationProps: annotation.toJSON() });
-                        elem.insert();
-                        imodel.saveChanges();
+                        withEditTxn(imodel, (txn) => elem.insert(txn));
                         const context = new IModelElementCloneContext(imodel);
                         context.remapElement("0x123", "0x456");
                         context.remapElement("0xabc", "0xdef");
@@ -527,9 +547,14 @@ describe("TextAnnotation element", () => {
                     let dstElemArgs;
                     before(async () => {
                         dstDb = await createIModel("CloneTarget");
-                        const jobSubjectId = createJobSubjectElement(dstDb, "Job").insert();
-                        dstDefModel = DefinitionModel.insert(dstDb, jobSubjectId, "Definition");
-                        const { category, model } = insertDrawingModel(dstDb, jobSubjectId, dstDefModel);
+                        let jobSubjectId;
+                        let category;
+                        let model;
+                        withEditTxn(dstDb, (txn) => {
+                            jobSubjectId = createJobSubjectElement(dstDb, "Job").insert(txn);
+                            dstDefModel = DefinitionModel.insert(txn, jobSubjectId, "Definition");
+                            ({ category, model } = insertDrawingModel(txn, jobSubjectId, dstDefModel));
+                        });
                         expect(category).not.to.equal(createElement2dArgs.category);
                         expect(model).not.to.equal(createElement2dArgs.model);
                         dstElemArgs = { category, model };
@@ -560,8 +585,7 @@ describe("TextAnnotation element", () => {
                         });
                         const annotation = TextAnnotation.create({ textBlock });
                         const elem = createElement2d(imodel, { ...createElement2dArgs, textAnnotationProps: annotation.toJSON() });
-                        elem.insert();
-                        imodel.saveChanges();
+                        withEditTxn(imodel, (txn) => elem.insert(txn));
                         const context = new IModelElementCloneContext(imodel, dstDb);
                         context.remapElement("0x123", "0x456");
                         context.remapElement("0xabc", "0xdef");
@@ -581,7 +605,7 @@ describe("TextAnnotation element", () => {
                         expect(props.defaultTextStyle).to.be.undefined;
                     });
                     it("remaps to an existing text style with the same code if present", async () => {
-                        const dstStyleId = createAnnotationTextStyle(dstDb, dstDefModel, "test", { font: { name: "Karla" } }).insert();
+                        const dstStyleId = withEditTxn(dstDb, (txn) => createAnnotationTextStyle(dstDb, dstDefModel, "test", { font: { name: "Karla" } }).insert(txn));
                         expect(dstStyleId).not.to.equal(seedStyleId);
                         const srcElem = insertStyledElement(seedStyleId, imodel);
                         const context = new IModelElementCloneContext(imodel, dstDb);
@@ -600,29 +624,35 @@ describe("TextAnnotation element", () => {
                         const context = new IModelElementCloneContext(imodel, dstDb);
                         context.remapElement(createElement2dArgs.model, dstElemArgs.model);
                         context.remapElement(seedDefinitionModelId, dstDefModel);
+                        const txn = new EditTxn(dstDb, "import default text style if necessary");
+                        txn.start();
                         const props = await context.cloneElement(srcElem);
+                        txn.end();
                         const dstStyleId = props.defaultTextStyle.id;
                         expect(dstStyleId).not.to.be.undefined;
                         expect(dstStyleId).not.to.equal(seedStyleId2);
                         expect(dstDb.elements.tryGetElement(dstStyleId)).not.to.be.undefined;
                     });
                     it("remaps multiple occurrences of same style to same Id", async () => {
-                        const srcStyleId = createAnnotationTextStyle(imodel, seedDefinitionModelId, "styyyle", { font: { name: "Karla" } }).insert();
+                        const srcStyleId = withEditTxn(imodel, (editTxn) => createAnnotationTextStyle(imodel, seedDefinitionModelId, "styyyle", { font: { name: "Karla" } }).insert(editTxn));
                         const srcElem1 = insertStyledElement(srcStyleId, imodel);
                         const srcElem2 = insertStyledElement(srcStyleId, imodel);
                         const srcElem3 = insertStyledElement(srcStyleId, imodel);
                         const context = new IModelElementCloneContext(imodel, dstDb);
                         context.remapElement(createElement2dArgs.model, dstElemArgs.model);
                         context.remapElement(seedDefinitionModelId, dstDefModel);
+                        const context2 = new IModelElementCloneContext(imodel, dstDb);
+                        context2.remapElement(createElement2dArgs.model, dstElemArgs.model);
+                        context2.remapElement(seedDefinitionModelId, dstDefModel);
+                        const txn = new EditTxn(dstDb, "remap repeated text styles");
+                        txn.start();
                         const props1 = await context.cloneElement(srcElem1);
                         const props2 = await context.cloneElement(srcElem2);
+                        const props3 = await context2.cloneElement(srcElem3);
+                        txn.end();
                         expect(props1.defaultTextStyle).not.to.be.undefined;
                         expect(props1.defaultTextStyle?.id).not.to.equal(srcStyleId);
                         expect(props2.defaultTextStyle?.id).to.equal(props1.defaultTextStyle?.id);
-                        const context2 = new IModelElementCloneContext(imodel, dstDb);
-                        context2.remapElement(createElement2dArgs.model, dstElemArgs.model);
-                        context2.remapElement(seedDefinitionModelId, dstDefModel);
-                        const props3 = await context2.cloneElement(srcElem3);
                         expect(props3.defaultTextStyle?.id).to.equal(props1.defaultTextStyle?.id);
                     });
                 });
@@ -631,7 +661,11 @@ describe("TextAnnotation element", () => {
         describe("TextAnnotation3d", () => {
             let createElement3dArgs;
             before(() => {
-                const { category, model } = insertSpatialModel(imodel, seedSubjectId, seedDefinitionModelId);
+                let category;
+                let model;
+                withEditTxn(imodel, (txn) => {
+                    ({ category, model } = insertSpatialModel(txn, seedSubjectId, seedDefinitionModelId));
+                });
                 expect(category).not.to.be.undefined;
                 expect(model).not.to.be.undefined;
                 createElement3dArgs = { category, model };
@@ -642,7 +676,7 @@ describe("TextAnnotation element", () => {
                 const el0 = createElement3d(imodel, args);
                 expect(el0.defaultTextStyle).not.to.be.undefined;
                 expect(el0.defaultTextStyle.id).to.equal(seedStyleId);
-                el0.insert();
+                withEditTxn(imodel, (txn) => el0.insert(txn));
                 const el1 = imodel.elements.getElement(el0.id);
                 expect(el1).not.to.be.undefined;
                 expect(el1.defaultTextStyle).not.to.be.undefined;
@@ -664,7 +698,7 @@ describe("TextAnnotation element", () => {
                 const args = { ...createElement3dArgs, textAnnotationProps: annotation.toJSON() };
                 const el0 = createElement3d(imodel, args);
                 el0.defaultTextStyle = undefined;
-                const elId = el0.insert();
+                const elId = withEditTxn(imodel, (txn) => el0.insert(txn));
                 expect(Id64.isValidId64(elId)).to.be.true;
                 const el1 = imodel.elements.getElement(elId);
                 expect(el1).not.to.be.undefined;
@@ -680,8 +714,12 @@ describe("AnnotationTextStyle", () => {
     let seedDefinitionModel;
     before(async () => {
         imodel = await createIModel("AnnotationTextStyle");
-        const jobSubjectId = createJobSubjectElement(imodel, "Job").insert();
-        const definitionModel = DefinitionModel.insert(imodel, jobSubjectId, "Definition");
+        let jobSubjectId;
+        let definitionModel;
+        withEditTxn(imodel, (txn) => {
+            jobSubjectId = createJobSubjectElement(imodel, "Job").insert(txn);
+            definitionModel = DefinitionModel.insert(txn, jobSubjectId, "Definition");
+        });
         expect(jobSubjectId).not.to.be.undefined;
         expect(definitionModel).not.to.be.undefined;
         seedSubjectId = jobSubjectId;
@@ -697,7 +735,7 @@ describe("AnnotationTextStyle", () => {
             textHeight: 0.5
         });
         const el0 = createAnnotationTextStyle(imodel, seedDefinitionModel, "round-trip", textStyle.toJSON());
-        const elId = el0.insert();
+        const elId = withEditTxn(imodel, (txn) => el0.insert(txn));
         expect(Id64.isValidId64(elId)).to.be.true;
         const el1 = imodel.elements.getElement(elId);
         expect(el1).not.to.be.undefined;
@@ -707,36 +745,40 @@ describe("AnnotationTextStyle", () => {
         expect(style.toJSON()).to.deep.equal(textStyle.toJSON());
     });
     it("does not allow elements with invalid styles to be inserted", async () => {
-        // Default style should fail since it has no font
-        let annotationTextStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "default");
-        expect(() => annotationTextStyle.insert()).to.throw();
-        // font is required
-        annotationTextStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "no font", { font: { name: "" } });
-        expect(() => annotationTextStyle.insert()).to.throw();
-        // textHeight should be positive
-        annotationTextStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "invalid textHeight", { font: { name: "Totally Real Font" }, textHeight: 0 });
-        expect(() => annotationTextStyle.insert()).to.throw();
-        // stackedFractionScale should be positive
-        annotationTextStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "invalid stackedFractionScale", { font: { name: "Totally Real Font" }, stackedFractionScale: 0 });
-        expect(() => annotationTextStyle.insert()).to.throw();
+        withEditTxn(imodel, (txn) => {
+            // Default style should fail since it has no font
+            let annotationTextStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "default");
+            expect(() => annotationTextStyle.insert(txn)).to.throw();
+            // font is required
+            annotationTextStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "no font", { font: { name: "" } });
+            expect(() => annotationTextStyle.insert(txn)).to.throw();
+            // textHeight should be positive
+            annotationTextStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "invalid textHeight", { font: { name: "Totally Real Font" }, textHeight: 0 });
+            expect(() => annotationTextStyle.insert(txn)).to.throw();
+            // stackedFractionScale should be positive
+            annotationTextStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "invalid stackedFractionScale", { font: { name: "Totally Real Font" }, stackedFractionScale: 0 });
+            expect(() => annotationTextStyle.insert(txn)).to.throw();
+        });
     });
     it("does not allow updating of elements to invalid styles", async () => {
         const annotationTextStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "valid style", { font: { name: "Totally Real Font" } });
-        const elId = annotationTextStyle.insert();
+        const elId = withEditTxn(imodel, (txn) => annotationTextStyle.insert(txn));
         expect(Id64.isValidId64(elId)).to.be.true;
-        const el1 = imodel.elements.getElement(elId);
-        expect(el1).not.to.be.undefined;
-        expect(el1 instanceof AnnotationTextStyle).to.be.true;
-        el1.settings = el1.settings.clone({ font: { name: "" } });
-        expect(() => el1.update()).to.throw();
-        el1.settings = el1.settings.clone({ font: { name: "Totally Real Font" }, textHeight: 0 });
-        expect(() => el1.update()).to.throw();
-        el1.settings = el1.settings.clone({ textHeight: 2, stackedFractionScale: 0 });
-        expect(() => el1.update()).to.throw();
-        el1.settings = el1.settings.clone({ stackedFractionScale: 0.45 });
-        el1.update();
+        withEditTxn(imodel, (txn) => {
+            const el1 = imodel.elements.getElement(elId);
+            expect(el1).not.to.be.undefined;
+            expect(el1 instanceof AnnotationTextStyle).to.be.true;
+            el1.settings = el1.settings.clone({ font: { name: "" } });
+            expect(() => el1.update(txn)).to.throw();
+            el1.settings = el1.settings.clone({ font: { name: "Totally Real Font" }, textHeight: 0 });
+            expect(() => el1.update(txn)).to.throw();
+            el1.settings = el1.settings.clone({ textHeight: 2, stackedFractionScale: 0 });
+            expect(() => el1.update(txn)).to.throw();
+            el1.settings = el1.settings.clone({ stackedFractionScale: 0.45 });
+            el1.update(txn);
+        });
         const updatedElement = imodel.elements.getElement(elId);
-        expect(updatedElement.settings.toJSON()).to.deep.equal(el1.settings.toJSON());
+        expect(updatedElement.settings.stackedFractionScale).to.equal(0.45);
     });
     it("uses default style if none specified", async () => {
         const el0 = AnnotationTextStyle.fromJSON({
@@ -870,13 +912,17 @@ describe("AnnotationTextStyle", () => {
         before(async () => {
             // The source and target iModel will both contain the Karla font family.
             targetDb = await createIModel("AnnotationTextStyleTargetDb");
-            const jobSubjectId = createJobSubjectElement(targetDb, "Job").insert();
-            targetDefModel = DefinitionModel.insert(targetDb, jobSubjectId, "Definition");
+            withEditTxn(targetDb, (txn) => {
+                const jobSubjectId = createJobSubjectElement(targetDb, "Job").insert(txn);
+                targetDefModel = DefinitionModel.insert(txn, jobSubjectId, "Definition");
+            });
             // Embed a font into the source iModel that doesn't exist in the target iModel.
             const shxName = IModelTestUtils.resolveFontFile("Cdm.shx");
             const shxBlob = fs.readFileSync(shxName);
             const shxFile = FontFile.createFromShxFontBlob({ blob: shxBlob, familyName: "Cdm" });
-            await imodel.fonts.embedFontFile({ file: shxFile });
+            await withEditTxn(imodel, async () => {
+                await imodel.fonts.embedFontFile({ file: shxFile });
+            });
         });
         after(() => targetDb.close());
         it("embeds font into target Db if not already embedded", async () => {
@@ -893,9 +939,11 @@ describe("AnnotationTextStyle", () => {
             };
             const initialCounts = getFontCounts();
             const karlaStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "karla-style", TextStyleSettings.fromJSON({ font: { name: "Karla" } }));
-            karlaStyle.insert();
             const cdmStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "cdm-style", TextStyleSettings.fromJSON({ font: { name: "Cdm", type: FontType.Shx } }));
-            cdmStyle.insert();
+            withEditTxn(imodel, (txn) => {
+                karlaStyle.insert(txn);
+                cdmStyle.insert(txn);
+            });
             const context = new IModelElementCloneContext(imodel, targetDb);
             context.remapElement(seedDefinitionModel, targetDefModel);
             expect(targetDb.fonts.findId({ name: "Karla" })).not.to.be.undefined;
@@ -919,11 +967,19 @@ describe("appendTextAnnotationGeometry", () => {
     let annotationRenderPriority;
     before(async () => {
         imodel = await createIModel("DefaultTextStyle");
-        const jobSubjectId = createJobSubjectElement(imodel, "Job").insert();
-        const definitionModel = DefinitionModel.insert(imodel, jobSubjectId, "Definition");
-        const { category, model } = insertDrawingModel(imodel, jobSubjectId, definitionModel);
-        const styleId = createAnnotationTextStyle(imodel, definitionModel, "test", { font: { name: "Totally Real Font" }, textHeight: 0.25, isItalic: true }).insert();
-        const differentStyleId = createAnnotationTextStyle(imodel, definitionModel, "alt", { font: { name: "Karla" }, textHeight: 0.5, isBold: true }).insert();
+        let jobSubjectId;
+        let definitionModel;
+        let category;
+        let model;
+        let styleId;
+        let differentStyleId;
+        withEditTxn(imodel, (txn) => {
+            jobSubjectId = createJobSubjectElement(imodel, "Job").insert(txn);
+            definitionModel = DefinitionModel.insert(txn, jobSubjectId, "Definition");
+            ({ category, model } = insertDrawingModel(txn, jobSubjectId, definitionModel));
+            styleId = createAnnotationTextStyle(imodel, definitionModel, "test", { font: { name: "Totally Real Font" }, textHeight: 0.25, isItalic: true }).insert(txn);
+            differentStyleId = createAnnotationTextStyle(imodel, definitionModel, "alt", { font: { name: "Karla" }, textHeight: 0.5, isBold: true }).insert(txn);
+        });
         expect(jobSubjectId).not.to.be.undefined;
         expect(definitionModel).not.to.be.undefined;
         expect(category).not.to.be.undefined;
@@ -978,12 +1034,13 @@ describe("appendTextAnnotationGeometry", () => {
     it("produces geometry when given an empty annotation with frame styling", () => {
         const block = TextBlock.create();
         const annotation = TextAnnotation.fromJSON({ textBlock: block.toJSON() });
-        const styleId = createAnnotationTextStyle(imodel, seedDefinitionModelId, "empty anno style", {
+        const style = createAnnotationTextStyle(imodel, seedDefinitionModelId, "empty anno style", {
             font: { name: "Totally Real Font" },
             frame: {
                 shape: "rectangle",
             }
-        }).insert();
+        });
+        const styleId = withEditTxn(imodel, (txn) => style.insert(txn));
         const builder = runAppendTextAnnotationGeometry(annotation, styleId);
         expect(builder.geometries).not.to.be.empty;
         expect(builder.params).not.to.be.empty;