@fluid-experimental/tree 0.58.2002 → 0.59.1000

package/lib/test/LogViewer.tests.js

@@ -5,73 +5,125 @@
 import { expect } from 'chai';
 import { v4 as uuidv4 } from 'uuid';
 import { EditLog } from '../EditLog';
-import { Change, ConstraintEffect, Insert, StablePlace, StableRange, Transaction } from '../default-edits';
-import { CachingLogViewer } from '../LogViewer';
-import { Snapshot } from '../Snapshot';
-import { assert, noop } from '../Common';
-import { newEdit, EditStatus } from '../generic';
-import { initialSnapshot, left, leftTraitLabel, leftTraitLocation, makeEmptyNode, right, rightTraitLocation, simpleTestTree, simpleTreeSnapshot, } from './utilities/TestUtilities';
-import { MockTransaction } from './utilities/MockTransaction';
-const simpleTreeNoTraits = Object.assign(Object.assign({}, simpleTestTree), { traits: {} });
-const simpleSnapshotNoTraits = Snapshot.fromTree(simpleTreeNoTraits);
-function getSimpleLog(numEdits = 2) {
+import { CachingLogViewer, } from '../LogViewer';
+import { assert, copyPropertyIfDefined } from '../Common';
+import { initialTree } from '../InitialTree';
+import { ChangeInternal, ChangeTypeInternal, ConstraintEffect, EditStatus, StablePlaceInternal, } from '../persisted-types';
+import { areRevisionViewsSemanticallyEqual, newEdit } from '../EditUtilities';
+import { RevisionView } from '../RevisionView';
+import { TransactionInternal } from '../TransactionInternal';
+import { StableRange } from '../ChangeTypes';
+import { expectDefined } from './utilities/TestCommon';
+import { buildLeaf } from './utilities/TestNode';
+import { refreshTestTree, testTraitLabel } from './utilities/TestUtilities';
+/**
+ * Creates an {@link EditLog} and accompanying {@link RevisionView} with pre-existing edits.
+ *
+ * @remarks Intended to be used with {@link getSimpleLogBaseView}
+ * @param testTree - Test tree to work on
+ * @param numEdits - The number of edits to make to the base tree
+ */
+function getTestTreeLog(testTree) {
+    const log = new EditLog();
+    log.addSequencedEdit(newEdit(ChangeInternal.insertTree([testTree.buildLeaf(testTree.left.identifier)], StablePlaceInternal.atStartOf(testTree.left.traitLocation))), { sequenceNumber: 1, referenceSequenceNumber: 0 });
+    log.addSequencedEdit(newEdit(ChangeInternal.insertTree([testTree.buildLeaf(testTree.right.identifier)], StablePlaceInternal.atStartOf(testTree.right.traitLocation))), { sequenceNumber: 2, referenceSequenceNumber: 1 });
+    return log;
+}
+function getLogWithNumEdits(nodeIdContext, numEdits) {
     const log = new EditLog();
     for (let i = 0; i < numEdits; i++) {
-        log.addSequencedEdit(newEdit(i % 2 === 0
-            ? Insert.create([left], StablePlace.atStartOf(leftTraitLocation))
-            : Insert.create([right], StablePlace.atStartOf(rightTraitLocation))), { sequenceNumber: i + 1, referenceSequenceNumber: i });
+        log.addSequencedEdit(newEdit(ChangeInternal.insertTree([buildLeaf(nodeIdContext.generateNodeId())], StablePlaceInternal.atStartOf({
+            label: testTraitLabel,
+            parent: nodeIdContext.convertToNodeId(initialTree.identifier),
+        }))), {
+            sequenceNumber: i + 1,
+            referenceSequenceNumber: i,
+        });
     }
     return log;
 }
-function getSimpleLogWithLocalEdits(numSequencedEdits = 2) {
-    const logWithLocalEdits = getSimpleLog(numSequencedEdits);
-    logWithLocalEdits.addLocalEdit(newEdit(Insert.create([makeEmptyNode()], StablePlace.atEndOf(leftTraitLocation))));
-    logWithLocalEdits.addLocalEdit(newEdit(Insert.create([makeEmptyNode()], StablePlace.atEndOf(rightTraitLocation))));
-    logWithLocalEdits.addLocalEdit(newEdit(Insert.create([makeEmptyNode()], StablePlace.atStartOf(leftTraitLocation))));
+/**
+ * Get a base view for a log created with {@link getTestTreeLog}.
+ * This can then be used to construct a {@link LogViewer} for that log.
+ *
+ * @param testTree - Test tree to work from
+ */
+function getSimpleLogBaseView(testTree) {
+    const node = { definition: testTree.definition, identifier: testTree.identifier, traits: {} };
+    copyPropertyIfDefined(testTree, node, 'payload');
+    return RevisionView.fromTree(node);
+}
+function getSimpleLogWithLocalEdits(testTree) {
+    const logWithLocalEdits = getTestTreeLog(testTree);
+    logWithLocalEdits.addLocalEdit(newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atEndOf(testTree.left.traitLocation))));
+    logWithLocalEdits.addLocalEdit(newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atEndOf(testTree.right.traitLocation))));
+    logWithLocalEdits.addLocalEdit(newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atEndOf(testTree.left.traitLocation))));
     return logWithLocalEdits;
 }
-function getSnapshotsForLog(log, baseSnapshot) {
-    const snapshots = [baseSnapshot];
+function getViewsForLog(log, baseView) {
+    const views = [baseView];
     for (let i = 0; i < log.length; i++) {
         const edit = log.getEditInSessionAtIndex(i);
-        snapshots.push(new Transaction(snapshots[i]).applyChanges(edit.changes).view);
+        const result = TransactionInternal.factory(views[i]).applyChanges(edit.changes).close();
+        if (result.status === EditStatus.Applied) {
+            views.push(result.after);
+        }
+        else {
+            expect.fail('edit failed to apply');
+        }
     }
-    return snapshots;
+    return views;
 }
 function runLogViewerCorrectnessTests(viewerCreator) {
     return describe('LogViewer', () => {
-        const log = getSimpleLog();
+        let simpleLog;
+        let simpleLogBaseView;
+        let simpleLogInitialView;
+        const testTree = refreshTestTree(undefined, (t) => {
+            simpleLogBaseView = getSimpleLogBaseView(t);
+            simpleLog = getTestTreeLog(t);
+            simpleLogInitialView = t.view;
+        });
         it('generates initialTree by default for the 0th revision', () => {
-            const viewer = viewerCreator(new EditLog());
-            const headSnapshot = viewer.getSnapshotInSession(0);
-            expect(headSnapshot.equals(initialSnapshot)).to.be.true;
+            const viewer = viewerCreator(new EditLog(), simpleLogBaseView);
+            const headView = viewer.getRevisionViewInSession(0);
+            expect(headView.equals(expectDefined(RevisionView.fromTree(initialTree, testTree))));
         });
         it('can be constructed from a non-empty EditLog', () => {
-            const viewer = viewerCreator(log, simpleSnapshotNoTraits);
-            const headSnapshot = viewer.getSnapshotInSession(Number.POSITIVE_INFINITY);
-            expect(headSnapshot.equals(simpleTreeSnapshot)).to.be.true;
+            const viewer = viewerCreator(simpleLog, simpleLogBaseView);
+            const headView = viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
+            expect(areRevisionViewsSemanticallyEqual(headView, testTree, simpleLogInitialView, testTree));
+            expect(headView.equals(simpleLogInitialView)).to.be.true;
         });
-        it('can generate all snapshots for an EditLog', () => {
-            const viewer = viewerCreator(log, simpleSnapshotNoTraits);
-            const initialSnapshot = viewer.getSnapshotInSession(0);
-            expect(initialSnapshot.equals(simpleSnapshotNoTraits)).to.be.true;
-            const leftOnlySnapshot = viewer.getSnapshotInSession(1);
-            expect(leftOnlySnapshot.equals(Snapshot.fromTree(Object.assign(Object.assign({}, simpleTestTree), { traits: { [leftTraitLabel]: [left] } })))).to.be.true;
-            const fullTreeSnapshot = viewer.getSnapshotInSession(2);
-            expect(fullTreeSnapshot.equals(simpleTreeSnapshot)).to.be.true;
+        it('can generate all revision views for an EditLog', () => {
+            const baseView = expectDefined(RevisionView.fromTree(initialTree, testTree));
+            const numNodes = 10;
+            const viewer = viewerCreator(getLogWithNumEdits(testTree, numNodes), baseView);
+            const initialRevision = viewer.getRevisionViewInSession(0);
+            expect(initialRevision.equals(baseView)).to.be.true;
+            expect(initialRevision.size).to.equal(1);
+            const oneNodeView = viewer.getRevisionViewInSession(1);
+            const testTrait = {
+                label: testTraitLabel,
+                parent: testTree.convertToNodeId(initialTree.identifier),
+            };
+            expect(oneNodeView.getTrait(testTrait).length).to.equal(1);
+            const twoNodeView = viewer.getRevisionViewInSession(2);
+            expect(twoNodeView.getTrait(testTrait).length).to.equal(2);
+            const finalView = viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
+            expect(finalView.getTrait(testTrait).length).to.equal(numNodes);
         });
-        it('produces correct snapshots when the log is mutated', () => {
-            const simpleLog = getSimpleLog();
+        it('produces correct revision views when the log is mutated', () => {
             const mutableLog = new EditLog();
-            const viewer = viewerCreator(mutableLog, simpleSnapshotNoTraits);
-            const snapshotsForLog = getSnapshotsForLog(simpleLog, simpleSnapshotNoTraits);
+            const viewer = viewerCreator(mutableLog, simpleLogBaseView);
+            const viewsForLog = getViewsForLog(simpleLog, simpleLogBaseView);
             // This test takes an empty log (A) and a log with edits in it (B), and adds the edits from B to A.
-            // After each addition, the test code will iterate from [0, length_of_A] and get a snapshot for each revision via LogViewer
-            // and assert that none of the snapshots differ from those created via pure Transaction APIs.
+            // After each addition, the test code will iterate from [0, length_of_A] and get a view for each revision via LogViewer
+            // and assert that none of the views differ from those created via pure Transaction APIs.
             for (let i = 0; i <= simpleLog.length; i++) {
                 for (let j = 0; j <= mutableLog.length; j++) {
-                    const viewerSnapshot = viewer.getSnapshotInSession(j);
-                    expect(viewerSnapshot.equals(snapshotsForLog[j])).to.be.true;
+                    const viewerView = viewer.getRevisionViewInSession(j);
+                    expect(viewerView.equals(viewsForLog[j])).to.be.true;
                 }
                 // Revisions are from [0, simpleLog.length], edits are at indices [0, simpleLog.length)
                 if (i < simpleLog.length) {
@@ -80,95 +132,111 @@ function runLogViewerCorrectnessTests(viewerCreator) {
                 }
             }
         });
-        it('produces correct snapshots when local edits are shifted in the log due to sequenced edits being added', () => {
-            function getSnapshotsFromViewer(viewer, lastRevision) {
-                const snapshots = [];
+        it('produces correct revision views when local edits are shifted in the log due to sequenced edits being added', () => {
+            function getViewsFromViewer(viewer, lastRevision) {
+                const views = [];
                 for (let i = 0; i <= lastRevision; i++) {
-                    snapshots.push(viewer.getSnapshotInSession(i));
+                    views.push(viewer.getRevisionViewInSession(i));
                 }
-                return snapshots;
+                return views;
             }
-            function expectSnapshotsAreEqual(log, viewer) {
-                const snapshotsForLog = getSnapshotsForLog(log, simpleSnapshotNoTraits);
-                const snapshotsForViewer = getSnapshotsFromViewer(viewer, log.length);
-                expect(snapshotsForLog.length).to.equal(snapshotsForViewer.length);
-                for (let i = 0; i < snapshotsForLog.length; i++) {
-                    expect(snapshotsForLog[i].equals(snapshotsForViewer[i])).to.be.true;
+            function expectViewsAreEqual(log, viewer) {
+                const viewsForLog = getViewsForLog(log, simpleLogBaseView);
+                const viewsForViewer = getViewsFromViewer(viewer, log.length);
+                expect(viewsForLog.length).to.equal(viewsForViewer.length);
+                for (let i = 0; i < viewsForLog.length; i++) {
+                    expect(viewsForLog[i].equals(viewsForViewer[i])).to.be.true;
                 }
             }
-            const logWithLocalEdits = getSimpleLogWithLocalEdits();
-            const viewer = viewerCreator(logWithLocalEdits, simpleSnapshotNoTraits);
-            expectSnapshotsAreEqual(logWithLocalEdits, viewer);
+            const logWithLocalEdits = getSimpleLogWithLocalEdits(testTree);
+            const viewer = viewerCreator(logWithLocalEdits, simpleLogBaseView);
+            expectViewsAreEqual(logWithLocalEdits, viewer);
             let seqNumber = 1;
-            // Sequence the existing local edits and ensure viewer generates the correct snapshots
+            // Sequence the existing local edits and ensure viewer generates the correct views
             while (logWithLocalEdits.numberOfLocalEdits > 0) {
                 // Add a remote sequenced edit
-                logWithLocalEdits.addSequencedEdit(newEdit(Insert.create([makeEmptyNode()], StablePlace.atStartOf(rightTraitLocation))), { sequenceNumber: seqNumber, referenceSequenceNumber: seqNumber - 1 });
+                logWithLocalEdits.addSequencedEdit(newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atStartOf(testTree.right.traitLocation))), { sequenceNumber: seqNumber, referenceSequenceNumber: seqNumber - 1 });
                 ++seqNumber;
-                expectSnapshotsAreEqual(logWithLocalEdits, viewer);
+                expectViewsAreEqual(logWithLocalEdits, viewer);
                 // Sequence a local edit
                 logWithLocalEdits.addSequencedEdit(logWithLocalEdits.getEditInSessionAtIndex(logWithLocalEdits.numberOfSequencedEdits), { sequenceNumber: seqNumber, referenceSequenceNumber: seqNumber - 1 });
                 ++seqNumber;
-                expectSnapshotsAreEqual(logWithLocalEdits, viewer);
+                expectViewsAreEqual(logWithLocalEdits, viewer);
             }
         });
     });
 }
 describe('CachingLogViewer', () => {
-    function getMockLogger(callback) {
-        return { send: callback !== null && callback !== void 0 ? callback : noop };
-    }
-    function getCachingLogViewerAssumeAppliedEdits(log, baseSnapshot, editCallback, logger, knownRevisions) {
-        return new CachingLogViewer(log, baseSnapshot, knownRevisions === null || knownRevisions === void 0 ? void 0 : knownRevisions.map((pair) => [pair[0], { snapshot: pair[1], result: EditStatus.Applied }]), 
-        /* expensiveValidation */ true, editCallback, logger !== null && logger !== void 0 ? logger : getMockLogger(), Transaction.factory, log.numberOfSequencedEdits);
+    // TODO: Dedupe? shared hook for getting all of this stuff?
+    let simpleLog;
+    let simpleLogBaseView;
+    let simpleLogInitialView;
+    // An arbitrary revision view which can be used to check to see if it gets used when provided as a cached value.
+    let arbitraryRevisionView;
+    const testTree = refreshTestTree(undefined, (t) => {
+        simpleLogBaseView = getSimpleLogBaseView(t);
+        simpleLog = getTestTreeLog(t);
+        simpleLogInitialView = t.view;
+        arbitraryRevisionView = RevisionView.fromTree(t.buildLeaf(t.generateNodeId()));
+    });
+    function getCachingLogViewerAssumeAppliedEdits(log, baseView, editStatusCallback, sequencedEditResultCallback, knownRevisions) {
+        return new CachingLogViewer(log, baseView, knownRevisions === null || knownRevisions === void 0 ? void 0 : knownRevisions.map((pair) => [pair[0], { view: pair[1], result: EditStatus.Applied }]), 
+        /* expensiveValidation */ true, editStatusCallback, sequencedEditResultCallback, log.numberOfSequencedEdits);
     }
     runLogViewerCorrectnessTests(getCachingLogViewerAssumeAppliedEdits);
-    it('detects non-integer revisions when setting snapshots', async () => {
-        expect(() => getCachingLogViewerAssumeAppliedEdits(getSimpleLog(), simpleSnapshotNoTraits, undefined, undefined, [
-            [2.4, simpleTreeSnapshot],
-        ])).to.throw('revision must be an integer');
+    it('detects non-integer revisions when setting revision views', async () => {
+        expect(() => {
+            return getCachingLogViewerAssumeAppliedEdits(simpleLog, simpleLogBaseView, undefined, undefined, [
+                [2.4, simpleLogInitialView],
+            ]);
+        }).to.throw('revision must be an integer');
     });
-    it('detects out-of-bounds revisions when setting snapshots', async () => {
-        expect(() => getCachingLogViewerAssumeAppliedEdits(getSimpleLog(), simpleSnapshotNoTraits, undefined, undefined, [
-            [1000, simpleTreeSnapshot],
-        ])).to.throw('revision must correspond to the result of a SequencedEdit');
+    it('detects out-of-bounds revisions when setting revision views', async () => {
+        expect(() => {
+            return getCachingLogViewerAssumeAppliedEdits(simpleLog, simpleLogBaseView, undefined, undefined, [
+                [1000, simpleLogInitialView],
+            ]);
+        }).to.throw('revision must correspond to the result of a SequencedEdit');
     });
     it('can be created with known revisions', async () => {
-        const log = getSimpleLog();
-        const snapshots = getSnapshotsForLog(log, simpleSnapshotNoTraits);
-        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleSnapshotNoTraits, undefined, undefined, Array.from(snapshots.keys()).map((revision) => [revision, snapshots[revision]]));
-        for (let i = log.length; i >= 0; i--) {
-            const snapshot = snapshots[i];
-            expect(viewer.getSnapshotInSession(i).equals(snapshot)).to.be.true;
+        const views = getViewsForLog(simpleLog, simpleLogBaseView);
+        const viewer = getCachingLogViewerAssumeAppliedEdits(simpleLog, simpleLogBaseView, undefined, undefined, Array.from(views.keys()).map((revision) => [revision, views[revision]]));
+        for (let i = simpleLog.length; i >= 0; i--) {
+            expect(viewer.getRevisionViewInSession(i).equals(views[i])).to.be.true;
         }
     });
-    async function requestAllSnapshots(viewer, log) {
+    async function requestAllRevisionViews(viewer, log) {
         for (let i = 0; i <= log.length; i++) {
-            await viewer.getSnapshot(i);
+            await viewer.getRevisionView(i);
         }
     }
-    it('caches snapshots for sequenced edits', async () => {
-        const log = getSimpleLog();
+    it('caches revision views for sequenced edits', async () => {
         let editsProcessed = 0;
-        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleSnapshotNoTraits, () => editsProcessed++);
-        assert(log.length < CachingLogViewer.sequencedCacheSizeMax);
-        await requestAllSnapshots(viewer, log);
-        expect(editsProcessed).to.equal(log.length);
-        // Ask for every snapshot; no edit application should occur, since the snapshots will be cached.
-        for (let i = 0; i <= log.length; i++) {
-            await viewer.getSnapshot(i);
+        const viewer = getCachingLogViewerAssumeAppliedEdits(simpleLog, simpleLogBaseView, () => editsProcessed++);
+        assert(simpleLog.length < CachingLogViewer.sequencedCacheSizeMax);
+        await requestAllRevisionViews(viewer, simpleLog);
+        expect(editsProcessed).to.equal(simpleLog.length);
+        // Ask for every view; no edit application should occur, since the views will be cached.
+        for (let i = 0; i <= simpleLog.length; i++) {
+            await viewer.getRevisionView(i);
         }
-        expect(editsProcessed).to.equal(log.length);
+        expect(editsProcessed).to.equal(simpleLog.length);
     });
     it('caches edit results for sequenced edits', async () => {
-        const log = getSimpleLog(2);
         // Add an invalid edit
-        log.addSequencedEdit(newEdit([Change.constraint(StableRange.only(left), ConstraintEffect.InvalidAndDiscard, undefined, 0)]), { sequenceNumber: 3, referenceSequenceNumber: 2, minimumSequenceNumber: 2 });
+        simpleLog.addSequencedEdit(newEdit([
+            {
+                type: ChangeTypeInternal.Constraint,
+                toConstrain: StableRange.only(testTree.left),
+                effect: ConstraintEffect.InvalidAndDiscard,
+                length: 0,
+            },
+        ]), { sequenceNumber: 3, referenceSequenceNumber: 2, minimumSequenceNumber: 2 });
         let editsProcessed = 0;
-        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleSnapshotNoTraits, () => editsProcessed++);
-        assert(log.length < CachingLogViewer.sequencedCacheSizeMax);
-        await requestAllSnapshots(viewer, log);
-        expect(editsProcessed).to.equal(log.length);
+        const viewer = getCachingLogViewerAssumeAppliedEdits(simpleLog, simpleLogBaseView, () => editsProcessed++);
+        assert(simpleLog.length < CachingLogViewer.sequencedCacheSizeMax);
+        await requestAllRevisionViews(viewer, simpleLog);
+        expect(editsProcessed).to.equal(simpleLog.length);
         expect((await viewer.getEditResult(0)).status).equals(undefined);
         expect((await viewer.getEditResult(1)).status).equals(EditStatus.Applied);
         expect((await viewer.getEditResult(2)).status).equals(EditStatus.Applied);
@@ -178,209 +246,226 @@ describe('CachingLogViewer', () => {
         expect(viewer.getEditResultInSession(2).status).equals(EditStatus.Applied);
         expect(viewer.getEditResultInSession(3).status).equals(EditStatus.Invalid);
     });
-    it('evicts least recently set cached snapshots for sequenced edits', async () => {
+    it('caches the highest revision', async () => {
+        const viewer = getCachingLogViewerAssumeAppliedEdits(simpleLog, simpleLogBaseView);
+        expect(viewer.highestRevisionCached()).to.be.false;
+        await requestAllRevisionViews(viewer, simpleLog);
+        expect(viewer.highestRevisionCached()).to.be.true;
+        simpleLog.addLocalEdit(newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atEndOf(testTree.right.traitLocation))));
+        simpleLog.addSequencedEdit(newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atEndOf(testTree.right.traitLocation))), {
+            sequenceNumber: 3,
+            referenceSequenceNumber: 2,
+            minimumSequenceNumber: 2,
+        });
+        expect(viewer.highestRevisionCached()).to.be.false;
+    });
+    it('evicts least recently set cached revision views for sequenced edits', async () => {
         let editsProcessed = 0;
-        const log = getSimpleLog(CachingLogViewer.sequencedCacheSizeMax * 2);
-        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleSnapshotNoTraits, () => editsProcessed++);
+        const log = getLogWithNumEdits(testTree, CachingLogViewer.sequencedCacheSizeMax * 2);
+        const viewer = getCachingLogViewerAssumeAppliedEdits(log, expectDefined(RevisionView.fromTree(initialTree, testTree)), () => editsProcessed++);
         viewer.setMinimumSequenceNumber(log.length + 1); // simulate all edits being subject to eviction
-        await requestAllSnapshots(viewer, log);
+        await requestAllRevisionViews(viewer, log);
         expect(editsProcessed).to.equal(log.length);
         editsProcessed = 0;
         for (let i = CachingLogViewer.sequencedCacheSizeMax + 1; i <= log.length; i++) {
-            await viewer.getSnapshot(i);
+            await viewer.getRevisionView(i);
         }
         expect(editsProcessed).to.equal(0);
-        await viewer.getSnapshot(CachingLogViewer.sequencedCacheSizeMax);
+        await viewer.getRevisionView(CachingLogViewer.sequencedCacheSizeMax);
         expect(editsProcessed).to.equal(CachingLogViewer.sequencedCacheSizeMax);
     });
-    it('never evicts the snapshot for the most recent sequenced edit', async () => {
+    it('never evicts the revision view for the most recent sequenced edit', async () => {
         let editsProcessed = 0;
-        const log = getSimpleLog(CachingLogViewer.sequencedCacheSizeMax * 2);
-        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleSnapshotNoTraits, () => editsProcessed++);
+        const log = getLogWithNumEdits(testTree, CachingLogViewer.sequencedCacheSizeMax * 2);
+        const viewer = getCachingLogViewerAssumeAppliedEdits(log, expectDefined(RevisionView.fromTree(initialTree, testTree)), () => editsProcessed++);
         // Simulate all clients being caught up.
         viewer.setMinimumSequenceNumber(log.numberOfSequencedEdits);
-        await requestAllSnapshots(viewer, log);
+        await requestAllRevisionViews(viewer, log);
         expect(editsProcessed).to.equal(log.length);
         editsProcessed = 0;
         for (let i = 0; i <= CachingLogViewer.sequencedCacheSizeMax; i++) {
-            await viewer.getSnapshot(i);
+            await viewer.getRevisionView(i);
         }
         expect(editsProcessed).to.equal(CachingLogViewer.sequencedCacheSizeMax);
         editsProcessed = 0;
-        await viewer.getSnapshot(log.numberOfSequencedEdits);
+        await viewer.getRevisionView(log.numberOfSequencedEdits);
         expect(editsProcessed).to.equal(0);
     });
-    it('caches snapshots for local revisions', async () => {
-        const logWithLocalEdits = getSimpleLogWithLocalEdits();
+    it('caches revision views for local revisions', async () => {
+        const logWithLocalEdits = getSimpleLogWithLocalEdits(testTree);
         let editsProcessed = 0;
-        const viewer = getCachingLogViewerAssumeAppliedEdits(logWithLocalEdits, simpleSnapshotNoTraits, () => editsProcessed++);
+        const viewer = getCachingLogViewerAssumeAppliedEdits(logWithLocalEdits, simpleLogBaseView, () => editsProcessed++);
         assert(logWithLocalEdits.length < CachingLogViewer.sequencedCacheSizeMax);
-        await requestAllSnapshots(viewer, logWithLocalEdits);
+        await requestAllRevisionViews(viewer, logWithLocalEdits);
         expect(editsProcessed).to.equal(logWithLocalEdits.length);
         // Local edits should now be cached until next remote sequenced edit arrives
         editsProcessed = 0;
         for (let i = logWithLocalEdits.numberOfSequencedEdits + 1; i <= logWithLocalEdits.length; i++) {
-            await viewer.getSnapshot(i);
+            await viewer.getRevisionView(i);
             expect(editsProcessed).to.equal(0);
         }
         // Add a new local edit, and request the latest view.
         // This should apply only a single edit, as the most recent HEAD should be cached.
         editsProcessed = 0;
-        logWithLocalEdits.addLocalEdit(newEdit(Insert.create([makeEmptyNode()], StablePlace.atEndOf(rightTraitLocation))));
-        await requestAllSnapshots(viewer, logWithLocalEdits);
+        logWithLocalEdits.addLocalEdit(newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atEndOf(testTree.right.traitLocation))));
+        await requestAllRevisionViews(viewer, logWithLocalEdits);
         expect(editsProcessed).to.equal(1);
         editsProcessed = 0;
         let seqNumber = 1;
         while (logWithLocalEdits.numberOfLocalEdits > 0) {
             logWithLocalEdits.addSequencedEdit(logWithLocalEdits.getEditInSessionAtIndex(logWithLocalEdits.numberOfSequencedEdits), { sequenceNumber: seqNumber, referenceSequenceNumber: seqNumber - 1 });
             ++seqNumber;
-            await viewer.getSnapshot(logWithLocalEdits.numberOfSequencedEdits); // get the latest (just added) sequenced edit
-            await viewer.getSnapshot(Number.POSITIVE_INFINITY); // get the last snapshot, which is a local revision
+            await viewer.getRevisionView(logWithLocalEdits.numberOfSequencedEdits); // get the latest (just added) sequenced edit
+            await viewer.getRevisionView(Number.POSITIVE_INFINITY); // get the last view, which is a local revision
             expect(editsProcessed).to.equal(0);
         }
     });
-    it('invalidates cached snapshots for local revisions when remote edits are received', () => {
-        const logWithLocalEdits = getSimpleLogWithLocalEdits();
+    it('invalidates cached revision views for local revisions when remote edits are received', () => {
+        const logWithLocalEdits = getSimpleLogWithLocalEdits(testTree);
         let editsProcessed = 0;
-        const viewer = getCachingLogViewerAssumeAppliedEdits(logWithLocalEdits, simpleSnapshotNoTraits, () => editsProcessed++);
+        const viewer = getCachingLogViewerAssumeAppliedEdits(logWithLocalEdits, simpleLogBaseView, () => editsProcessed++);
         // Request twice, should only process edits once
-        viewer.getSnapshotInSession(Number.POSITIVE_INFINITY);
-        viewer.getSnapshotInSession(Number.POSITIVE_INFINITY);
+        viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
+        viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
         expect(editsProcessed).to.equal(logWithLocalEdits.length);
         // Remote edit arrives
         editsProcessed = 0;
-        logWithLocalEdits.addSequencedEdit(newEdit(Insert.create([makeEmptyNode()], StablePlace.atEndOf(rightTraitLocation))), { sequenceNumber: 3, referenceSequenceNumber: 2, minimumSequenceNumber: 2 });
-        viewer.getSnapshotInSession(Number.POSITIVE_INFINITY);
+        logWithLocalEdits.addSequencedEdit(newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atEndOf(testTree.right.traitLocation))), { sequenceNumber: 3, referenceSequenceNumber: 2, minimumSequenceNumber: 2 });
+        viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
         expect(editsProcessed).to.equal(logWithLocalEdits.numberOfLocalEdits + 1);
     });
-    // An arbitrary snapshot which can be used to check to see if it gets used when provided as a cached value.
-    const arbitrarySnapshot = Snapshot.fromTree(makeEmptyNode());
     it('uses known editing result', () => {
         const log = new EditLog();
         const editsProcessed = [];
-        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleSnapshotNoTraits, (_, _2, wasCached) => editsProcessed.push(wasCached));
-        const before = viewer.getSnapshotInSession(Number.POSITIVE_INFINITY);
+        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleLogBaseView, (_, _2, wasCached) => editsProcessed.push(wasCached));
+        const before = viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
         const edit = newEdit([]);
         log.addLocalEdit(edit);
         viewer.setKnownEditingResult(edit, {
             status: EditStatus.Applied,
             changes: edit.changes,
             before,
-            after: arbitrarySnapshot,
+            after: arbitraryRevisionView,
             steps: [],
         });
-        const after = viewer.getSnapshotInSession(Number.POSITIVE_INFINITY);
+        const after = viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
         expect(editsProcessed).deep.equal([true]);
-        expect(after).equal(arbitrarySnapshot);
+        expect(after).equal(arbitraryRevisionView);
     });
-    it('ignores known editing if for wrong before snapshot', () => {
+    it('ignores known editing if for wrong before revision view', () => {
         const log = new EditLog();
         const editsProcessed = [];
-        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleSnapshotNoTraits, (_, _2, wasCached) => editsProcessed.push(wasCached));
+        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleLogBaseView, (_, _2, wasCached) => editsProcessed.push(wasCached));
         const edit = newEdit([]);
         log.addLocalEdit(edit);
         viewer.setKnownEditingResult(edit, {
             status: EditStatus.Applied,
             changes: edit.changes,
-            before: arbitrarySnapshot,
-            after: arbitrarySnapshot,
+            before: arbitraryRevisionView,
+            after: arbitraryRevisionView,
             steps: [],
         });
-        const after = viewer.getSnapshotInSession(Number.POSITIVE_INFINITY);
+        const after = viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
         expect(editsProcessed).deep.equal([false]);
-        expect(after).not.equal(arbitrarySnapshot);
+        expect(after).not.equal(arbitraryRevisionView);
     });
     it('ignores known editing if for wrong edit', () => {
         const log = new EditLog();
         const editsProcessed = [];
-        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleSnapshotNoTraits, (_, _2, wasCached) => editsProcessed.push(wasCached));
-        const before = viewer.getSnapshotInSession(Number.POSITIVE_INFINITY);
+        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleLogBaseView, (_, _2, wasCached) => editsProcessed.push(wasCached));
+        const before = viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
         const edit = newEdit([]);
         log.addLocalEdit(edit);
         viewer.setKnownEditingResult(newEdit([]), {
             status: EditStatus.Applied,
             changes: edit.changes,
             before,
-            after: arbitrarySnapshot,
+            after: arbitraryRevisionView,
             steps: [],
         });
-        const after = viewer.getSnapshotInSession(Number.POSITIVE_INFINITY);
+        const after = viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
         expect(editsProcessed).deep.equal([false]);
-        expect(after).not.equal(arbitrarySnapshot);
+        expect(after).not.equal(arbitraryRevisionView);
     });
     it('uses known editing result with multiple edits', () => {
         const log = new EditLog();
         const editsProcessed = [];
-        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleSnapshotNoTraits, (_, _2, wasCached) => editsProcessed.push(wasCached));
+        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleLogBaseView, (_, _2, wasCached) => editsProcessed.push(wasCached));
         const edit1 = newEdit([]);
         const edit2 = newEdit([]);
         const edit3 = newEdit([]);
         log.addLocalEdit(edit1);
-        const before = viewer.getSnapshotInSession(Number.POSITIVE_INFINITY);
+        const before = viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
         expect(editsProcessed).deep.equal([false]);
         log.addLocalEdit(edit2);
         viewer.setKnownEditingResult(edit2, {
             status: EditStatus.Applied,
             changes: edit2.changes,
             before,
-            after: arbitrarySnapshot,
+            after: arbitraryRevisionView,
             steps: [],
         });
-        const after = viewer.getSnapshotInSession(Number.POSITIVE_INFINITY);
+        const after = viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
         expect(editsProcessed).deep.equal([false, true]);
-        expect(after).equal(arbitrarySnapshot);
+        expect(after).equal(arbitraryRevisionView);
         log.addLocalEdit(edit3);
-        viewer.getSnapshotInSession(Number.POSITIVE_INFINITY);
+        viewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
         expect(editsProcessed).deep.equal([false, true, false]);
     });
-    describe('Telemetry', () => {
+    describe('Callbacks', () => {
         function getViewer() {
-            const log = getSimpleLog();
+            const log = getTestTreeLog(testTree);
             const events = [];
-            const viewer = new CachingLogViewer(log, simpleSnapshotNoTraits, [], 
-            /* expensiveValidation */ true, undefined, getMockLogger((event) => events.push(event)), Transaction.factory);
+            const viewer = new CachingLogViewer(log, simpleLogBaseView, [], 
+            /* expensiveValidation */ true, undefined, (args) => events.push(args));
             return { log, viewer, events };
         }
         function addInvalidEdit(log) {
             // Add a local edit that will be invalid (inserts a node at a location that doesn't exist)
-            const edit = newEdit(Insert.create([makeEmptyNode()], StablePlace.atEndOf({
-                parent: initialSnapshot.root,
-                label: leftTraitLabel,
-            })));
+            const edit = newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], expectDefined(StablePlaceInternal.atEndOf({
+                label: testTraitLabel,
+                parent: testTree.generateNodeId(),
+            }))));
             log.addLocalEdit(edit);
             return edit;
         }
-        it('is logged for invalid locally generated edits when those edits are sequenced', async () => {
-            const { log, events, viewer } = getViewer();
-            const edit = addInvalidEdit(log);
-            await viewer.getSnapshot(Number.POSITIVE_INFINITY);
-            expect(events.length).equals(0, 'Invalid local edit should not log telemetry');
-            log.addSequencedEdit(edit, { sequenceNumber: 3, referenceSequenceNumber: 2 });
-            await viewer.getSnapshot(Number.POSITIVE_INFINITY);
-            expect(events.length).equals(1);
-        });
-        it('is only logged once upon first application for invalid locally generated edits', async () => {
+        it('processSequencedEditResult is called when a sequenced edit is applied', async () => {
             const { log, events, viewer } = getViewer();
-            const numEdits = 10;
-            const localEdits = [...Array(numEdits).keys()].map(() => addInvalidEdit(log));
-            await viewer.getSnapshot(Number.POSITIVE_INFINITY);
+            await viewer.getRevisionView(Number.POSITIVE_INFINITY);
+            events.splice(0);
+            // Non-sequenced edit should not trigger a call
+            const invalidEdit = addInvalidEdit(log);
+            await viewer.getRevisionView(Number.POSITIVE_INFINITY);
             expect(events.length).equals(0);
-            for (let i = 0; i < numEdits; i++) {
-                const localEdit = localEdits[i];
-                log.addSequencedEdit(localEdit, { sequenceNumber: i + 1, referenceSequenceNumber: 1 });
-                await viewer.getSnapshot(Number.POSITIVE_INFINITY);
-                expect(events.length).equals(i + 1);
-                const currentEvent = events[i];
-                expect(currentEvent.category).equals('generic');
-                expect(currentEvent.eventName).equals('InvalidSharedTreeEdit');
-            }
+            log.addSequencedEdit(invalidEdit, { sequenceNumber: 3, referenceSequenceNumber: 2 });
+            await viewer.getRevisionView(Number.POSITIVE_INFINITY);
+            expect(events.length).equals(1);
+            expect(events[0].edit.id).equals(invalidEdit.id);
+            expect(events[0].wasLocal).equals(true);
+            expect(events[0].result.status).equals(EditStatus.Invalid);
+            expect(events[0].reconciliationPath.length).equals(0);
+            const validEdit1 = newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atStartOf(testTree.left.traitLocation)));
+            log.addSequencedEdit(validEdit1, { sequenceNumber: 3, referenceSequenceNumber: 2 });
+            await viewer.getRevisionView(Number.POSITIVE_INFINITY);
+            expect(events.length).equals(2);
+            expect(events[1].edit.id).equals(validEdit1.id);
+            expect(events[1].wasLocal).equals(false);
+            expect(events[1].result.status).equals(EditStatus.Applied);
+            expect(events[1].reconciliationPath.length).equals(0);
+            const validEdit2 = newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atStartOf(testTree.left.traitLocation)));
+            log.addSequencedEdit(validEdit2, { sequenceNumber: 4, referenceSequenceNumber: 2 });
+            await viewer.getRevisionView(Number.POSITIVE_INFINITY);
+            expect(events.length).equals(3);
+            expect(events[2].edit.id).equals(validEdit2.id);
+            expect(events[2].wasLocal).equals(false);
+            expect(events[2].result.status).equals(EditStatus.Applied);
+            expect(events[2].reconciliationPath.length).equals(1);
         });
     });
     describe('Sequencing', () => {
         function addFakeEdit(logViewer, sequenceNumber, referenceSequenceNumber) {
             const id = String(sequenceNumber !== null && sequenceNumber !== void 0 ? sequenceNumber : uuidv4());
-            const fakeChange = id;
-            const edit = { changes: [fakeChange], id };
+            const edit = { changes: [ChangeInternal.setPayload(simpleLogBaseView.root, id)], id };
             logViewer.log.addSequencedEdit(edit, {
                 sequenceNumber,
                 referenceSequenceNumber: referenceSequenceNumber !== null && referenceSequenceNumber !== void 0 ? referenceSequenceNumber : sequenceNumber - 1,
@@ -388,8 +473,7 @@ describe('CachingLogViewer', () => {
             return edit;
         }
         function minimalLogViewer() {
-            return new CachingLogViewer(new EditLog(), undefined, [], 
-            /* expensiveValidation */ true, undefined, getMockLogger(), MockTransaction.factory);
+            return new CachingLogViewer(new EditLog(), simpleLogBaseView, [], /* expensiveValidation */ true);
         }
         it('tracks the earliest sequenced edit in the session', () => {
             const logViewer = minimalLogViewer();
@@ -445,7 +529,8 @@ describe('CachingLogViewer', () => {
                 expect(actual.length).equals(path.length);
                 for (let i = 0; i < path.length; ++i) {
                     expect(actual[i].length).equals(1);
-                    expect(actual[i][0].resolvedChange).equals(path[i].id);
+                    const change = actual[i][0].resolvedChange;
+                    expect(change.payload).equals(path[i].id);
                 }
             }
             // Non-sequenced edit
@@ -458,11 +543,11 @@ describe('CachingLogViewer', () => {
             // This is deliberately done to simulate scenarios where a given DDS may not be sent all sequenced ops (because an other DDS
             // might be receiving them).
             const edit2 = addFakeEdit(logViewer, 2001, 1001);
-            expectReconciliationPath(edit2, [edit1]);
-            const edit3 = addFakeEdit(logViewer, 3001, 2001);
+            expectReconciliationPath(edit2, []);
+            const edit3 = addFakeEdit(logViewer, 3001, 2000);
             expectReconciliationPath(edit3, [edit2]);
             const edit4 = addFakeEdit(logViewer, 4001, 2500);
-            expectReconciliationPath(edit4, [edit2, edit3]);
+            expectReconciliationPath(edit4, [edit3]);
             const edit5 = addFakeEdit(logViewer, 5001, 500);
             expectReconciliationPath(edit5, [edit1, edit2, edit3, edit4]);
         });