easy-richtextarea 3.0.154 → 4.0.1

package/test/helpers.js

@@ -0,0 +1,85 @@
+"use strict";
+
+const randomSeed = require("random-seed");
+
+const { EmptyOperation, InsertOperation, DeleteOperation } = require("../lib/main");  ///
+
+const DEFAULT_CONTENT_LENGTH = 4,
+      DEFAULT_NUMBER_OF_OPERATIONS = 2,
+      MAXIMUM_INSERT_OPERATION_LENGTH = 4;
+
+const random = randomSeed.create(".");
+
+function content(length = DEFAULT_CONTENT_LENGTH) {
+  const string = generateString(length),
+        content = string; ///
+
+  return content;
+}
+
+function operations(content, numberOfOperations = DEFAULT_NUMBER_OF_OPERATIONS) {
+  const operations = [];
+
+  for (let i = 0; i < numberOfOperations; i++) {
+    const operation = generateOperation(content);
+
+    operations.push(operation);
+
+    content = operation.transformContent(content);
+  }
+
+  return operations;
+}
+
+module.exports = {
+  content,
+  operations
+};
+
+function generateString(length) {
+  let string = "";
+
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+
+  for (let index = 0; index < length; index++) {
+    string += characters.charAt(random(characters.length));
+  }
+
+  return string;
+}
+
+function generateOperation(string) {
+  if (string === "") {
+    return [
+      generateEmptyOperation,
+      generateInsertOperation
+    ][random(2)](string);
+  } else {
+    return [
+      generateEmptyOperation,
+      generateInsertOperation,
+      generateDeleteOperation
+    ][random(3)](string);
+  }
+}
+
+function generateEmptyOperation(string) {
+  return EmptyOperation.fromNothing();
+}
+
+function generateInsertOperation(string) {
+  const stringLength = string.length,
+        position = random(stringLength + 1);
+
+  string = generateString(MAXIMUM_INSERT_OPERATION_LENGTH); ///
+
+  return InsertOperation.fromStringAndPosition(string, position);
+}
+
+function generateDeleteOperation(string) {
+  const stringLength = string.length,
+        position = random(stringLength),
+        length = random(stringLength - position) + 1;
+
+  return DeleteOperation.fromLengthAndPosition(length, position);
+}

package/test/operation/delete.js

@@ -0,0 +1,245 @@
+"use strict";
+
+const { assert } = require("chai"),
+      { arrayUtilities } = require("necessary"),
+      { EmptyOperation, DeleteOperation, InsertOperation } = require("../../lib/main");  ///
+
+const helpers = require("../helpers");
+
+const { first } = arrayUtilities;
+
+describe("DeleteOperation", () => {
+  describe("transform", () => {
+    it("transforms an insert operation at position 2 to position 1", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(2, 1),
+            insertOperation2 = InsertOperation.fromStringAndPosition("b", 2),
+            transformedOperations = deleteOperation1.transformOperation(insertOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = InsertOperation.fromStringAndPosition("b", 1),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a delete operation of length 1 at position 2 to an empty operation", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(2, 1),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(1, 2),
+            transformedOperations = deleteOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = EmptyOperation.fromNothing(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+  
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a delete operation of length 2 at position 2 to a delete operation of length 1 at position 1", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(2, 1),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(2, 2),
+            transformedOperations = deleteOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = DeleteOperation.fromLengthAndPosition(1, 1),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms an insert operation at position 0, leaving it in the same position", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(1, 1),
+            insertOperation2 = InsertOperation.fromStringAndPosition("b", 0),
+            transformedOperations = deleteOperation1.transformOperation(insertOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = insertOperation2.clone(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms an insert operation at position 1, leaving it in the same position", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(1, 1),
+            insertOperation2 = InsertOperation.fromStringAndPosition("b", 1),
+            transformedOperations = deleteOperation1.transformOperation(insertOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = insertOperation2.clone(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms an insert operation at position 2 to position 1", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(1, 1),
+            insertOperation2 = InsertOperation.fromStringAndPosition("b", 2),
+            transformedOperations = deleteOperation1.transformOperation(insertOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = InsertOperation.fromStringAndPosition("b", 1),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms an empty operation, leaving it the same", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(1, 1),
+            emptyOperation2 = EmptyOperation.fromNothing(),
+            transformedOperations = deleteOperation1.transformOperation(emptyOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = emptyOperation2.clone(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a delete operation of length 1 at position 0, leaving it the same position", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(1, 1),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(1, 0),
+            transformedOperations = deleteOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = deleteOperation2.clone(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a delete operation of length 2 at position 0 to a delete operation of length 1 at position 0", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(1, 1),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(2, 0),
+            transformedOperations = deleteOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = DeleteOperation.fromLengthAndPosition(1, 0),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a delete operation of length 3 at position 0 to a delete operation of length 2 at position 0", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(1, 1),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(3, 0),
+            transformedOperations = deleteOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = DeleteOperation.fromLengthAndPosition(2, 0),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a delete operation of length 1 at position 1 to an empty operation", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(1, 1),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(1, 1),
+            transformedOperations = deleteOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = EmptyOperation.fromNothing(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a delete operation of length 2 at position 1 to a delete operation of length 1 at position 1", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(1, 1),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(2, 1),
+            transformedOperations = deleteOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = DeleteOperation.fromLengthAndPosition(1, 1),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a delete operation of length 1 at position 2 to a delete operation of length 1 at position 1", () => {
+      const deleteOperation1 = DeleteOperation.fromLengthAndPosition(1, 1),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(1, 2),
+            transformedOperations = deleteOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = DeleteOperation.fromLengthAndPosition(1, 1),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+  });
+
+  describe("transformContent", () => {
+    it("deletes the requisite characters from the content", () => {
+      const content = helpers.content(10),
+            deleteOperation = DeleteOperation.fromLengthAndPosition(6, 4),
+            transformedContent = deleteOperation.transformContent(content),
+            expectedContent = content.substring(0, 4);
+
+      assert.equal(transformedContent, expectedContent);
+    });
+  });
+
+  describe("fromJSON, toJSON", () => {
+    it("transforms from and to JSON, leaving the operation unchanged", () => {
+      const expectedJSON = {
+				      "type": "delete",
+              "length": 3,
+              "position": 1
+            },
+            json = DeleteOperation.fromJSON(expectedJSON).toJSON();
+
+      assert.deepEqual(json, expectedJSON);
+    });
+  });
+});

package/test/operation/empty.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const { assert } = require("chai"),
+      { arrayUtilities } = require("necessary"),
+      { EmptyOperation, DeleteOperation, InsertOperation } = require("../../lib/main");  ///
+
+const helpers = require("../helpers");
+
+const { first } = arrayUtilities;
+
+describe("EmptyOperation", () => {
+  describe("transform", () => {
+    it("transforms an insert operation, leaving it the same", () => {
+      const emptyOperation1 = EmptyOperation.fromNothing(),
+            insertOperation2 = InsertOperation.fromStringAndPosition(0, "b"),
+            transformedOperations = emptyOperation1.transformOperation(insertOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = insertOperation2.clone(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a second empty operation, leaving it the same", () => {
+      const emptyOperation1 = EmptyOperation.fromNothing(),
+            emptyOperation2 = EmptyOperation.fromNothing(),
+            transformedOperations = emptyOperation1.transformOperation(emptyOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = emptyOperation2.clone(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a delete operation, leaving it the same", () => {
+      const emptyOperation1 = EmptyOperation.fromNothing(),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(0, 1),
+            transformedOperations = emptyOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = deleteOperation2.clone(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON);
+    });
+  });
+
+  describe("transformContent", () => {
+    it("leaves the content unchanged", () => {
+      const content = helpers.content(),
+            emptyOperation = EmptyOperation.fromNothing(),
+            transformedContent = emptyOperation.transformContent(content),
+            expectedContent = content;  ///
+
+      assert.equal(transformedContent, expectedContent);
+    });
+  });
+
+  describe("fromJSON, toJSON", () => {
+    it("transforms from and to JSON, leaving the operation unchanged", () => {
+      const expectedJSON = {
+              "type": "empty"
+            },
+            json = EmptyOperation.fromJSON(expectedJSON).toJSON();
+
+      assert.deepEqual(json, expectedJSON);
+    });
+  });
+});

package/test/operation/insert.js

@@ -0,0 +1,201 @@
+"use strict";
+
+const { assert } = require("chai"),
+      { arrayUtilities } = require("necessary"),
+      { EmptyOperation, DeleteOperation, InsertOperation } = require("../../lib/main");  ///
+
+const helpers = require("../helpers");
+
+const { first, second } = arrayUtilities;
+
+describe("InsertOperation", () => {
+  describe("transform", () => {
+    it("transforms a second insert operation at position 0, leaving it in the same position", () => {
+      const insertOperation1 = InsertOperation.fromStringAndPosition("a", 1),
+            insertOperation2 = InsertOperation.fromStringAndPosition("b", 0),
+            transformedOperations = insertOperation1.transformOperation(insertOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = insertOperation2.clone(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a second, lexicographically lesser insert operation at position 1, leaving it in the same position", () => {
+      const insertOperation1 = InsertOperation.fromStringAndPosition("a", 1),
+            insertOperation2 = InsertOperation.fromStringAndPosition(" ", 1),
+            transformedOperations = insertOperation1.transformOperation(insertOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = insertOperation2.clone(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a second, equal insert operation, leaving it in the same position", () => {
+      const insertOperation1 = InsertOperation.fromStringAndPosition("a", 1),
+            insertOperation2 = insertOperation1.clone(),
+            transformedOperations = insertOperation1.transformOperation(insertOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = insertOperation1.clone(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a second, lexicographically greater insert operation at position 1 to position 2", () => {
+      const insertOperation1 = InsertOperation.fromStringAndPosition("a", 1),
+            insertOperation2 = InsertOperation.fromStringAndPosition("b", 1),
+            transformedOperations = insertOperation1.transformOperation(insertOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = InsertOperation.fromStringAndPosition("b", 2),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a second insert operation at position 2 to position 3", () => {
+      const insertOperation1 = InsertOperation.fromStringAndPosition("a", 1),
+            insertOperation2 = InsertOperation.fromStringAndPosition("b", 2),
+            transformedOperations = insertOperation1.transformOperation(insertOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = InsertOperation.fromStringAndPosition("b", 3),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms an empty operation, leaving it the same", () => {
+      const insertOperation1 = InsertOperation.fromStringAndPosition("a", 1),
+            emptyOperation2 = EmptyOperation.fromNothing(),
+            transformedOperations = insertOperation1.transformOperation(emptyOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = emptyOperation2.clone(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON)
+    });
+
+    it("transforms a delete operation at position 0 of length 1, leaving it the same position", () => {
+      const insertOperation1 = InsertOperation.fromStringAndPosition("a", 1),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(1, 0),
+            transformedOperations = insertOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = deleteOperation2.clone(),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON);
+    });
+
+    it("transforms a delete operation at position 0 of length 2, splitting it into two delete operations of length 1, the first at position 0 and the second at position 1", () => {
+      const insertOperation1 = InsertOperation.fromStringAndPosition("a", 1),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(2, 0),
+            transformedOperations = insertOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 2);
+
+      const firstTransformedOperation = first(transformedOperations),
+            secondTransformedOperation = second(transformedOperations),
+            firstTransformedOperationJSON = firstTransformedOperation.toJSON(),
+            secondTransformedOperationJSON = secondTransformedOperation.toJSON(),
+            firstExpectedTransformedOperation = DeleteOperation.fromLengthAndPosition(1, 0),
+            secondExpectedTransformedOperation = DeleteOperation.fromLengthAndPosition(1, 1),
+            firstExpectedTransformedOperationJSON = firstExpectedTransformedOperation.toJSON(),
+            secondExpectedTransformedOperationJSON = secondExpectedTransformedOperation.toJSON();
+
+      assert.deepEqual(firstTransformedOperationJSON, firstExpectedTransformedOperationJSON);
+      assert.deepEqual(secondTransformedOperationJSON, secondExpectedTransformedOperationJSON);
+    });
+
+    it("transforms a delete operation at position 1 of length 1 to position 2", () => {
+      const insertOperation1 = InsertOperation.fromStringAndPosition("a", 1),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(1, 1),
+            transformedOperations = insertOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = DeleteOperation.fromLengthAndPosition(1, 2),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON);
+    });
+
+    it("transforms a delete operation at position 2 of length 1 to position 3", () => {
+      const insertOperation1 = InsertOperation.fromStringAndPosition("a", 1),
+            deleteOperation2 = DeleteOperation.fromLengthAndPosition(1, 2),
+            transformedOperations = insertOperation1.transformOperation(deleteOperation2);
+
+      assert.lengthOf(transformedOperations, 1);
+
+      const firstTransformedOperation = first(transformedOperations),
+            transformedOperation = firstTransformedOperation, ///
+            transformedOperationJSON = transformedOperation.toJSON(),
+            expectedTransformedOperation = DeleteOperation.fromLengthAndPosition(1, 3),
+            expectedTransformedOperationJSON = expectedTransformedOperation.toJSON();
+
+      assert.deepEqual(transformedOperationJSON, expectedTransformedOperationJSON);
+    });
+  });
+
+  describe("transformContent", () => {
+    it("inserts the requisite characters into the content", () => {
+      const content = helpers.content(),
+            emptyOperation = InsertOperation.fromStringAndPosition("123", 0),
+            transformedContent = emptyOperation.transformContent(content),
+            expectedContent = `123${content}`;
+
+      assert.equal(transformedContent, expectedContent);
+    });
+  });
+
+  describe("fromJSON, toJSON", () => {
+    it("transforms from and to JSON, leaving the operation unchanged", () => {
+      const expectedJSON = {
+              "type": "insert",
+              "string": "a",
+              "position": 1
+            },
+            json = InsertOperation.fromJSON(expectedJSON).toJSON();
+
+      assert.deepEqual(json, expectedJSON);
+    });
+  });
+});