@fluidframework/merge-tree 2.22.0 → 2.22.1

package/dist/test/obliterate.concurrent.spec.js

@@ -1499,6 +1499,58 @@ for (const incremental of [true, false]) {
                 helper.processAllOps();
                 helper.logger.validate({ baseText: "8m" });
             });
+            // See 'Local obliterate wins post-insertion of segment previously thought to have won' (below) for a simpler
+            // to understand version of this test. This test is the original partial synchronization fuzz variant which
+            // demonstrated that issue, and has been preserved for now in case it catches additional related problems.
+            // Once fuzz testing more meaninfully leverages ops being sent to different clients at different types (partial
+            // synchronization), it's probably fine to remove this.
+            it("fuzz regression: Local obliterate wins post-insertion of segment previously thought to have won", () => {
+                const helper = new partialSyncHelper_js_1.PartialSyncTestHelper();
+                helper.insertText("A", 0, "Hx15J");
+                helper.processAllOps();
+                helper.insertText("A", 0, "9T");
+                helper.insertText("B", 0, "c8v");
+                helper.advanceClients("A", "C");
+                helper.removeRange("A", 2, 5);
+                helper.removeRange("A", 0, 1);
+                helper.obliterateRange("A", 0, 3);
+                helper.obliterateRange("C", { pos: 1, side: sequencePlace_js_1.Side.After }, { pos: 4, side: sequencePlace_js_1.Side.Before });
+                helper.insertText("B", 0, "4qpo");
+                helper.insertText("C", 2, "fP");
+                helper.insertText("A", 0, "hn");
+                helper.advanceClients("A", "C");
+                helper.obliterateRange("A", { pos: 5, side: sequencePlace_js_1.Side.After }, { pos: 9, side: sequencePlace_js_1.Side.After });
+                helper.obliterateRange("B", { pos: 3, side: sequencePlace_js_1.Side.Before }, { pos: 9, side: sequencePlace_js_1.Side.After });
+                // At the time of the original bug, this would hit 0xa3f.
+                helper.processAllOps();
+                helper.logger.validate({ baseText: "hn4qpJ" });
+            });
+            // Simpler version of the above test which has the same root cause but reproduces a slightly different failure mode.
+            it("Local obliterate wins post-insertion of segment previously thought to have won", () => {
+                const helper = new partialSyncHelper_js_1.PartialSyncTestHelper();
+                helper.insertText("A", 0, "1xx2");
+                helper.processAllOps();
+                // A and B both obliterate the 'xx' segment with an expanding obliterate, then try to insert
+                // into the gap that it leaves.
+                helper.obliterateRange("A", { pos: 0, side: sequencePlace_js_1.Side.After }, { pos: 3, side: sequencePlace_js_1.Side.Before });
+                helper.insertText("A", 1, "aaaa");
+                helper.obliterateRange("B", { pos: 0, side: sequencePlace_js_1.Side.After }, { pos: 3, side: sequencePlace_js_1.Side.Before });
+                helper.insertText("B", 1, "bbb");
+                helper.advanceClients("A", "B");
+                // Meanwhile, C attempts the same thing without seeing A or B's obliterate & insertions
+                helper.obliterateRange("C", { pos: 0, side: sequencePlace_js_1.Side.After }, { pos: 3, side: sequencePlace_js_1.Side.Before });
+                helper.insertText("C", 1, "ccc");
+                // Before seeing C's ops, B attempts to insert more content. Since B hasn't yet seen C's obliterate,
+                // A and B are under the impression that B's obliterate has won and the string contents are '1bbb2'.
+                helper.insertText("B", 5, "B");
+                helper.insertText("A", 5, "A");
+                helper.processAllOps();
+                // By now, all clients realize C actually won the obliterate and should have additionally applied B's
+                // op correctly as it was outside of the obliterated range.
+                // At the time this test was written, client C had trouble recognizing that A and B think that B has won
+                // and merged incorrectly, hitting 'MergeTree insert failed'.
+                helper.logger.validate({ baseText: "1ccc2AB" });
+            });
         });
     });
 }