@fluid-experimental/tree 0.59.1000 → 0.59.2000-63294

package/lib/test/utilities/SharedTreeTests.js

@@ -26,7 +26,7 @@ import { convertNodeDataIds } from '../../IdConversion';
 import { buildLeaf, SimpleTestTree } from './TestNode';
 import { TestFluidHandle, TestFluidSerializer } from './TestSerializer';
 import { runSharedTreeUndoRedoTestSuite } from './UndoRedoTests';
-import { areNodesEquivalent, assertNoDelta, setUpTestTree, testTrait, testTraitLabel, translateId, spyOnSubmittedOps, normalizeIds, normalizeId, normalizeEdit, setUpLocalServerTestSharedTree, applyNoop, getIdNormalizerFromSharedTree, waitForSummary, } from './TestUtilities';
+import { areNodesEquivalent, assertNoDelta, setUpTestTree, testTrait, testTraitLabel, translateId, spyOnSubmittedOps, normalizeIds, normalizeId, normalizeEdit, setUpLocalServerTestSharedTree, applyNoop, getIdNormalizerFromSharedTree, waitForSummary, getEditLogInternal, } from './TestUtilities';
 function revertEditInTree(tree, edit) {
     return tree.revert(edit);
 }
@@ -836,7 +836,7 @@ export function runSharedTreeOperationsTests(title, writeFormat, setUpTestShared
                 headers: { [LoaderHeader.version]: secondSummaryVersion },
             });
             // Verify we loaded a no-history summary.
-            expect(tree3.editsInternal.length).to.equal(1);
+            expect(tree3.edits.length).to.equal(1);
             let unexpectedHistoryChunkCount = 0;
             tree3.on(SharedTreeDiagnosticEvent.UnexpectedHistoryChunk, () => unexpectedHistoryChunkCount++);
             await testObjectProvider.ensureSynchronized();
@@ -885,10 +885,12 @@ export function runSharedTreeOperationsTests(title, writeFormat, setUpTestShared
                     expect(tree.equals(secondTree)).to.be.false;
                     containerRuntimeFactory.processAllMessages();
                     const { internedStrings } = tree.saveSummary();
-                    const insertEdit = normalizeEdit(tree, tree.editsInternal.getEditInSessionAtIndex(1));
-                    const moveEdit = normalizeEdit(tree, tree.editsInternal.getEditInSessionAtIndex(2));
-                    const insertEdit2 = normalizeEdit(secondTree, secondTree.editsInternal.getEditInSessionAtIndex(1));
-                    const moveEdit2 = normalizeEdit(secondTree, secondTree.editsInternal.getEditInSessionAtIndex(2));
+                    const log = getEditLogInternal(tree);
+                    const log2 = getEditLogInternal(secondTree);
+                    const insertEdit = normalizeEdit(tree, log.getEditInSessionAtIndex(1));
+                    const moveEdit = normalizeEdit(tree, log.getEditInSessionAtIndex(2));
+                    const insertEdit2 = normalizeEdit(secondTree, log2.getEditInSessionAtIndex(1));
+                    const moveEdit2 = normalizeEdit(secondTree, log2.getEditInSessionAtIndex(2));
                     expect(insertEdit).to.deep.equal(insertEdit2);
                     expect(moveEdit).to.deep.equal(moveEdit2);
                     expect(tree.equals(secondTree)).to.be.true;
@@ -920,7 +922,7 @@ export function runSharedTreeOperationsTests(title, writeFormat, setUpTestShared
                     const testTree = setUpTestTree(tree);
                     const uncompressedEdits = [
                         {
-                            changes: tree.edits.getEditInSessionAtIndex(0).changes,
+                            changes: getEditLogInternal(tree).getEditInSessionAtIndex(0).changes,
                         },
                     ];
                     // Apply enough edits for the upload of an edit chunk
@@ -955,6 +957,56 @@ export function runSharedTreeOperationsTests(title, writeFormat, setUpTestShared
                 });
             });
         }
+        describe('mergeEditsFrom', () => {
+            const getTestTreeRootHandle = (tree, testTree) => {
+                const view = tree.currentView;
+                const handle = new TreeNodeHandle(view, view.root);
+                return handle.traits[testTree.traitLabel][0];
+            };
+            it('can be used with simple edits', () => {
+                const { sharedTree, testTree } = createSimpleTestTree();
+                const { sharedTree: sharedTree2, testTree: testTree2 } = createSimpleTestTree();
+                sharedTree.applyEdit(...Change.insertTree(testTree.buildLeaf(), StablePlace.after(testTree.left)));
+                sharedTree.applyEdit(Change.delete(StableRange.all({ parent: testTree.identifier, label: testTree.right.traitLabel })));
+                const preEditRootHandle = getTestTreeRootHandle(sharedTree2, testTree2);
+                const edits = [0, 1, 2].map((i) => sharedTree.edits.getEditInSessionAtIndex(i));
+                // Since the TestTree setup edit is a `setTrait`, this should wipe `testTree2` state.
+                sharedTree2.mergeEditsFrom(sharedTree, edits);
+                expect(sharedTree2.edits.length).to.equal(4);
+                const rootHandle = getTestTreeRootHandle(sharedTree2, testTree2);
+                expect(preEditRootHandle.identifier).to.not.equal(rootHandle.identifier);
+                expect(rootHandle.traits[testTree2.left.traitLabel].length).to.equal(2);
+            });
+            it('can be used with a translation map', () => {
+                const { sharedTree, testTree } = createSimpleTestTree();
+                const { sharedTree: sharedTree2, testTree: testTree2 } = createSimpleTestTree();
+                // For each of the identities in the simple test tree...
+                const nodeIdGetters = [
+                    (tree) => tree.identifier,
+                    (tree) => tree.left.identifier,
+                    (tree) => tree.right.identifier,
+                ];
+                // Make a map translating that identifier from `testTree` to `testTree2`
+                const translationMap = new Map(nodeIdGetters.map((getter) => [
+                    sharedTree.convertToStableNodeId(getter(testTree)),
+                    sharedTree2.convertToStableNodeId(getter(testTree2)),
+                ]));
+                sharedTree.applyEdit(...Change.insertTree(testTree.buildLeaf(), StablePlace.after(testTree.left)));
+                sharedTree.applyEdit(Change.delete(StableRange.all({ parent: testTree.identifier, label: testTree.right.traitLabel })));
+                const edits = [1, 2].map((i) => sharedTree.edits.getEditInSessionAtIndex(i));
+                sharedTree2.mergeEditsFrom(sharedTree, edits, (id) => { var _a; return (_a = translationMap.get(id)) !== null && _a !== void 0 ? _a : id; });
+                const root = getTestTreeRootHandle(sharedTree, testTree);
+                const root2 = getTestTreeRootHandle(sharedTree2, testTree2);
+                const leftTrait = root.traits[testTree.left.traitLabel];
+                const leftTrait2 = root2.traits[testTree2.left.traitLabel];
+                // Inserted leaves should be equivalent.
+                expect(leftTrait2.length).to.equal(2);
+                expect(leftTrait2[1]).to.deep.equal(leftTrait[1]);
+                // Right subtree should have been deleted.
+                expect(Object.entries(root2.traits).length).to.equal(1);
+                expect(root2.traits[testTree2.right.traitLabel]).to.equal(undefined);
+            });
+        });
     });
 }
 //# sourceMappingURL=SharedTreeTests.js.map