easy-richtextarea 3.0.154 → 4.0.3

package/test/operations/generate.js

@@ -0,0 +1,81 @@
+"use strict";
+
+const { assert } = require("chai"),
+      { arrayUtilities } = require("necessary"),
+      { types, InsertOperation, DeleteOperation, generateOperations } = require("../../lib/main");  ///
+
+const helpers = require("../helpers");
+
+const{ first, second } = arrayUtilities,
+     { insertType, deleteType } = types;
+
+describe("generateOperations", () => {
+  describe("the contents are the same", () => {
+    it("generates a zero length array of operations", () => {
+      const content = helpers.content(),
+            operations = generateOperations(content, content);
+
+      assert.lengthOf(operations, 0);
+    });
+  });
+
+  describe("the second content is a subset of the first content", () => {
+    it("generates a array of operations containing an insert operation", () => {
+      const contentA = helpers.content(),
+            contentB = `123${contentA}`,
+            operations = generateOperations(contentA, contentB);
+
+      assert.lengthOf(operations, 1);
+
+      const firstOperation = first(operations),
+            insertOperation = InsertOperation.fromStringAndPosition("123", 0),
+            operation = firstOperation, ///
+            expectedOperation = insertOperation,  ///
+            operationJSON = operation.toJSON(),
+            expectedOperationJSON = expectedOperation.toJSON();
+
+      assert.deepEqual(operationJSON, expectedOperationJSON);
+    });
+  });
+
+  describe("the first content is a subset of second content", () => {
+    it("generates array of operations containing a delete operation", () => {
+      const contentB = helpers.content(),
+            contentA = `xyz${contentB}`,
+            operations = generateOperations(contentA, contentB);
+
+      assert.lengthOf(operations, 1);
+
+      const firstOperation = first(operations),
+            deleteOperation = DeleteOperation.fromLengthAndPosition(3, 0),
+            operation = firstOperation, ///
+            expectedOperation = deleteOperation,  ///
+            operationJSON = operation.toJSON(),
+            expectedOperationJSON = expectedOperation.toJSON();
+
+      assert.deepEqual(operationJSON, expectedOperationJSON);
+    });
+  });
+
+  describe("the contents are different", () => {
+    it("generates array of operations containing one delete operation followed by an insert operation", () => {
+      const contentA = helpers.content(),
+            contentB = helpers.content(),
+            operations = generateOperations(contentA, contentB);
+
+      assert.lengthOf(operations, 2);
+
+      const firstOperation = first(operations),
+            secondOperation = second(operations),
+            firstOperationJSON = firstOperation.toJSON(),
+            secondOperationJSON = secondOperation.toJSON(),
+            firstOperationType = firstOperationJSON["type"],
+            secondOperationType = secondOperationJSON["type"],
+            expectedFirstOperationType = deleteType,  ///
+            expectedSecondOperationType = insertType; ///
+
+      assert.deepEqual(firstOperationType, expectedFirstOperationType);
+      assert.deepEqual(secondOperationType, expectedSecondOperationType);
+    });
+  });
+});

package/test/operations/transform.js

@@ -0,0 +1,130 @@
+"use strict";
+
+const { assert } = require("chai"),
+      { transformContent, operationsFromJSON, transformOperations } = require("../../lib/main");  ///
+
+const helpers = require("../helpers");
+
+describe("transformOperations", () => {
+  describe("for two empty sequences of operations", () => {
+    it("The intentions are preserved", () => {
+      const firstOperationsJSON = [],
+            secondOperationsJSON = [],
+            firstOperations = operationsFromJSON(firstOperationsJSON),
+            secondOperations = operationsFromJSON(secondOperationsJSON);
+
+      assertIntentionsPreserved(firstOperations, secondOperations);
+    });
+  });
+
+  describe("for an array containing one operation and an empty sequence", () => {
+    it("The intentions are preserved", () => {
+      const firstOperationsJSON = [{
+              "type": "insert",
+              "string": "xyz",
+              "position": 1
+            }],
+            secondOperationsJSON = [],
+            firstOperations = operationsFromJSON(firstOperationsJSON),
+            secondOperations = operationsFromJSON(secondOperationsJSON);
+
+      assertIntentionsPreserved(firstOperations, secondOperations);
+    });
+  });
+
+  describe("for two sequences each containing one operation", () => {
+    it("The intentions are preserved", () => {
+      const firstOperationsJSON = [{
+              "type": "insert",
+              "string": "xyz",
+              "position": 1
+            }],
+            secondOperationsJSON = [{
+              "type": "delete",
+              "length": 2,
+              "position": 1
+            }],
+            firstOperations = operationsFromJSON(firstOperationsJSON),
+            secondOperations = operationsFromJSON(secondOperationsJSON);
+
+      assertIntentionsPreserved(firstOperations, secondOperations);
+    });
+  });
+
+  describe("for an array containing one operation and a sequence containing two operations", () => {
+    it("The intentions are preserved", () => {
+      const firstOperationsJSON = [{
+              "type": "insert",
+              "string": "xyz",
+              "position": 1,
+            }],
+            secondOperationsJSON = [{
+              "type": "insert",
+              "string": "abc",
+              "position": 3
+            },
+            {
+              "type": "delete",
+              "length": 2,
+              "position": 1,
+            }],
+            firstOperations = operationsFromJSON(firstOperationsJSON),
+            secondOperations = operationsFromJSON(secondOperationsJSON);
+
+      assertIntentionsPreserved(firstOperations, secondOperations);
+    });
+  });
+
+  describe("for two sequences each containing two operations", () => {
+    it("The intentions are preserved", () => {
+      const firstOperationsJSON = [{
+              "type": "delete",
+              "length": 6,
+              "position": 0
+            },
+            {
+              "type": "insert",
+              "string": "JQ",
+              "position": 0
+            }],
+            secondOperationsJSON = [{
+              "type": "delete",
+              "length": 4,
+              "position": 0
+            },
+            {
+              "type": "insert",
+              "string": "bkW",
+              "position": 0
+            }],
+            firstOperations = operationsFromJSON(firstOperationsJSON),
+            secondOperations = operationsFromJSON(secondOperationsJSON);
+
+      assertIntentionsPreserved(firstOperations, secondOperations);
+    });
+  });
+
+  describe("for two sequences each containing a hundred operations", () => {
+    it("The intentions are preserved", () => {
+      const content = helpers.content(100),
+            firstOperations = helpers.operations(content, 100),
+            secondOperations = helpers.operations(content, 100);
+
+      assertIntentionsPreserved(firstOperations, secondOperations);
+    });
+  });
+});
+
+function assertIntentionsPreserved(firstOperations, secondOperations) {
+  const content = helpers.content(100),
+        transformedFirstOperations = transformOperations(firstOperations, secondOperations),
+        transformedSecondOperations = transformOperations(secondOperations, firstOperations);
+
+  firstOperations = firstOperations.concat(transformedSecondOperations);
+  secondOperations = secondOperations.concat(transformedFirstOperations);
+
+  const firstTransformedContent = transformContent(content, firstOperations),
+        secondTransformedContent = transformContent(content, secondOperations);
+
+  assert.equal(firstTransformedContent, secondTransformedContent);
+}