@fluid-experimental/tree 2.0.0-rc.2.0.1 → 2.0.0-rc.3.0.0

package/lib/test/LogViewer.tests.js

@@ -1,588 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { strict as assert } from 'assert';
-import { expect } from 'chai';
-import { v4 as uuidv4 } from 'uuid';
-import { validateAssertionError } from '@fluidframework/test-runtime-utils';
-import { EditLog } from '../EditLog.js';
-import { CachingLogViewer, CachingLogViewerDiagnosticEvents, } from '../LogViewer.js';
-import { copyPropertyIfDefined, fail } from '../Common.js';
-import { initialTree } from '../InitialTree.js';
-import { ChangeInternal, ChangeTypeInternal, ConstraintEffect, EditStatus, StablePlaceInternal, } from '../persisted-types/index.js';
-import { areRevisionViewsSemanticallyEqual, newEdit } from '../EditUtilities.js';
-import { RevisionView } from '../RevisionView.js';
-import { TransactionInternal } from '../TransactionInternal.js';
-import { StableRange } from '../ChangeTypes.js';
-import { expectDefined } from './utilities/TestCommon.js';
-import { buildLeaf } from './utilities/TestNode.js';
-import { refreshTestTree, testTraitLabel } from './utilities/TestUtilities.js';
-/**
- * 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(ChangeInternal.insertTree([buildLeaf(nodeIdContext.generateNodeId())], StablePlaceInternal.atStartOf({
-            label: testTraitLabel,
-            parent: nodeIdContext.convertToNodeId(initialTree.identifier),
-        }))), {
-            sequenceNumber: i + 1,
-            referenceSequenceNumber: i,
-        });
-    }
-    return log;
-}
-/**
- * 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 getViewsForLog(log, baseView) {
-    const views = [baseView];
-    for (let i = 0; i < log.length; i++) {
-        const edit = log.tryGetEditAtIndex(i) ?? fail('edit not found');
-        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 views;
-}
-function runLogViewerCorrectnessTests(viewerCreator) {
-    return describe('LogViewer', () => {
-        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(), simpleLogBaseView);
-            const headView = viewer.getRevisionViewInMemory(0);
-            expect(headView.equals(expectDefined(RevisionView.fromTree(initialTree, testTree))));
-        });
-        it('can be constructed from a non-empty EditLog', () => {
-            const viewer = viewerCreator(simpleLog, simpleLogBaseView);
-            const headView = viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-            expect(areRevisionViewsSemanticallyEqual(headView, testTree, simpleLogInitialView, testTree));
-            expect(headView.equals(simpleLogInitialView)).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.getRevisionViewInMemory(0);
-            expect(initialRevision.equals(baseView)).to.be.true;
-            expect(initialRevision.size).to.equal(1);
-            const oneNodeView = viewer.getRevisionViewInMemory(1);
-            const testTrait = {
-                label: testTraitLabel,
-                parent: testTree.convertToNodeId(initialTree.identifier),
-            };
-            expect(oneNodeView.getTrait(testTrait).length).to.equal(1);
-            const twoNodeView = viewer.getRevisionViewInMemory(2);
-            expect(twoNodeView.getTrait(testTrait).length).to.equal(2);
-            const finalView = viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-            expect(finalView.getTrait(testTrait).length).to.equal(numNodes);
-        });
-        it('produces correct revision views when the log is mutated', () => {
-            const mutableLog = new EditLog();
-            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 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 viewerView = viewer.getRevisionViewInMemory(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) {
-                    const edit = simpleLog.tryGetEditAtIndex(i) ?? fail('edit not found');
-                    mutableLog.addSequencedEdit(edit, { sequenceNumber: i + 1, referenceSequenceNumber: i });
-                }
-            }
-        });
-        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++) {
-                    views.push(viewer.getRevisionViewInMemory(i));
-                }
-                return views;
-            }
-            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(testTree);
-            const viewer = viewerCreator(logWithLocalEdits, simpleLogBaseView);
-            expectViewsAreEqual(logWithLocalEdits, viewer);
-            let seqNumber = 1;
-            // Sequence the existing local edits and ensure viewer generates the correct views
-            while (logWithLocalEdits.numberOfLocalEdits > 0) {
-                // Add a remote sequenced edit
-                logWithLocalEdits.addSequencedEdit(newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atStartOf(testTree.right.traitLocation))), { sequenceNumber: seqNumber, referenceSequenceNumber: seqNumber - 1 });
-                ++seqNumber;
-                expectViewsAreEqual(logWithLocalEdits, viewer);
-                // Sequence a local edit
-                logWithLocalEdits.addSequencedEdit(logWithLocalEdits.tryGetEditAtIndex(logWithLocalEdits.numberOfSequencedEdits) ??
-                    fail('edit not found'), { sequenceNumber: seqNumber, referenceSequenceNumber: seqNumber - 1 });
-                ++seqNumber;
-                expectViewsAreEqual(logWithLocalEdits, viewer);
-            }
-        });
-    });
-}
-describe('CachingLogViewer', () => {
-    // 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, initialRevision) {
-        return new CachingLogViewer(log, baseView, initialRevision !== undefined
-            ? [initialRevision[0], { view: initialRevision[1], status: EditStatus.Applied, steps: [] }]
-            : undefined, editStatusCallback, sequencedEditResultCallback, log.numberOfSequencedEdits);
-    }
-    runLogViewerCorrectnessTests(getCachingLogViewerAssumeAppliedEdits);
-    it('detects non-integer revisions when setting revision views', async () => {
-        assert.throws(() => {
-            return getCachingLogViewerAssumeAppliedEdits(simpleLog, simpleLogBaseView, undefined, undefined, [
-                2.4,
-                simpleLogInitialView,
-            ]);
-        }, (e) => validateAssertionError(e, 'revision must be an integer'));
-    });
-    it('detects out-of-bounds revisions when setting revision views', async () => {
-        assert.throws(() => {
-            return getCachingLogViewerAssumeAppliedEdits(simpleLog, simpleLogBaseView, undefined, undefined, [
-                1000,
-                simpleLogInitialView,
-            ]);
-        }, (e) => validateAssertionError(e, 'revision must correspond to the result of a SequencedEdit'));
-    });
-    it('can be created with an initial revision', async () => {
-        const views = getViewsForLog(simpleLog, simpleLogBaseView);
-        const initialRevision = 0;
-        const viewer = getCachingLogViewerAssumeAppliedEdits(simpleLog, simpleLogBaseView, undefined, undefined, [initialRevision, views[initialRevision]]);
-        expect(viewer.getRevisionViewInMemory(initialRevision).equals(views[initialRevision])).to.be.true;
-    });
-    function requestAllRevisionViews(viewer, log) {
-        for (let i = 0; i <= log.length; i++) {
-            viewer.getRevisionViewInMemory(i);
-        }
-    }
-    it('caches revision views for sequenced edits', async () => {
-        let editsProcessed = 0;
-        const viewer = getCachingLogViewerAssumeAppliedEdits(simpleLog, simpleLogBaseView, () => editsProcessed++);
-        assert(simpleLog.length < CachingLogViewer.sequencedCacheSizeMax);
-        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++) {
-            viewer.getRevisionViewInMemory(i);
-        }
-        expect(editsProcessed).to.equal(simpleLog.length);
-    });
-    it('caches edit results for sequenced edits', async () => {
-        // Add an invalid edit
-        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(simpleLog, simpleLogBaseView, () => editsProcessed++);
-        assert(simpleLog.length < CachingLogViewer.sequencedCacheSizeMax);
-        requestAllRevisionViews(viewer, simpleLog);
-        expect(editsProcessed).to.equal(simpleLog.length);
-        expect(viewer.getEditResultInMemory(0).status).equals(undefined);
-        expect(viewer.getEditResultInMemory(1).status).equals(EditStatus.Applied);
-        expect(viewer.getEditResultInMemory(2).status).equals(EditStatus.Applied);
-        expect(viewer.getEditResultInMemory(3).status).equals(EditStatus.Invalid);
-    });
-    it('caches the highest revision', async () => {
-        const viewer = getCachingLogViewerAssumeAppliedEdits(simpleLog, simpleLogBaseView);
-        expect(viewer.highestRevisionCached()).to.be.false;
-        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 = 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
-        requestAllRevisionViews(viewer, log);
-        expect(editsProcessed).to.equal(log.length);
-        editsProcessed = 0;
-        for (let i = CachingLogViewer.sequencedCacheSizeMax + 1; i <= log.length; i++) {
-            viewer.getRevisionViewInMemory(i);
-        }
-        expect(editsProcessed).to.equal(0);
-        viewer.getRevisionViewInMemory(CachingLogViewer.sequencedCacheSizeMax);
-        expect(editsProcessed).to.equal(CachingLogViewer.sequencedCacheSizeMax);
-    });
-    it('never evicts the revision view for the most recent sequenced edit', async () => {
-        let editsProcessed = 0;
-        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);
-        requestAllRevisionViews(viewer, log);
-        expect(editsProcessed).to.equal(log.length);
-        editsProcessed = 0;
-        for (let i = 0; i <= CachingLogViewer.sequencedCacheSizeMax; i++) {
-            viewer.getRevisionViewInMemory(i);
-        }
-        expect(editsProcessed).to.equal(CachingLogViewer.sequencedCacheSizeMax);
-        editsProcessed = 0;
-        viewer.getRevisionViewInMemory(log.numberOfSequencedEdits);
-        expect(editsProcessed).to.equal(0);
-    });
-    it('caches revision views for local revisions', async () => {
-        const logWithLocalEdits = getSimpleLogWithLocalEdits(testTree);
-        let editsProcessed = 0;
-        const viewer = getCachingLogViewerAssumeAppliedEdits(logWithLocalEdits, simpleLogBaseView, () => editsProcessed++);
-        assert(logWithLocalEdits.length < CachingLogViewer.sequencedCacheSizeMax);
-        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++) {
-            viewer.getRevisionViewInMemory(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(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atEndOf(testTree.right.traitLocation))));
-        requestAllRevisionViews(viewer, logWithLocalEdits);
-        expect(editsProcessed).to.equal(1);
-        editsProcessed = 0;
-        let seqNumber = 1;
-        while (logWithLocalEdits.numberOfLocalEdits > 0) {
-            logWithLocalEdits.addSequencedEdit(logWithLocalEdits.tryGetEditAtIndex(logWithLocalEdits.numberOfSequencedEdits) ?? fail('edit not found'), { sequenceNumber: seqNumber, referenceSequenceNumber: seqNumber - 1 });
-            ++seqNumber;
-            viewer.getRevisionViewInMemory(logWithLocalEdits.numberOfSequencedEdits); // get the latest (just added) sequenced edit
-            viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY); // get the last view, which is a local revision
-            expect(editsProcessed).to.equal(0);
-        }
-    });
-    it('invalidates cached revision views for local revisions when remote edits are received', () => {
-        const logWithLocalEdits = getSimpleLogWithLocalEdits(testTree);
-        let editsProcessed = 0;
-        const viewer = getCachingLogViewerAssumeAppliedEdits(logWithLocalEdits, simpleLogBaseView, () => editsProcessed++);
-        // Request twice, should only process edits once
-        viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-        viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-        expect(editsProcessed).to.equal(logWithLocalEdits.length);
-        // Remote edit arrives
-        editsProcessed = 0;
-        logWithLocalEdits.addSequencedEdit(newEdit(ChangeInternal.insertTree([testTree.buildLeafInternal()], StablePlaceInternal.atEndOf(testTree.right.traitLocation))), { sequenceNumber: 3, referenceSequenceNumber: 2, minimumSequenceNumber: 2 });
-        viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-        expect(editsProcessed).to.equal(logWithLocalEdits.numberOfLocalEdits + 1);
-    });
-    it('uses known editing result', () => {
-        const log = new EditLog();
-        const editsProcessed = [];
-        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleLogBaseView, (_, _2, wasCached) => editsProcessed.push(wasCached));
-        const before = viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-        const edit = newEdit([]);
-        log.addLocalEdit(edit);
-        viewer.setKnownEditingResult(edit, {
-            status: EditStatus.Applied,
-            changes: edit.changes,
-            before,
-            after: arbitraryRevisionView,
-            steps: [],
-        });
-        const after = viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-        expect(editsProcessed).deep.equal([true]);
-        expect(after).equal(arbitraryRevisionView);
-    });
-    it('ignores known editing if for wrong before revision view', () => {
-        const log = new EditLog();
-        const editsProcessed = [];
-        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: arbitraryRevisionView,
-            after: arbitraryRevisionView,
-            steps: [],
-        });
-        const after = viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-        expect(editsProcessed).deep.equal([false]);
-        expect(after).not.equal(arbitraryRevisionView);
-    });
-    it('ignores known editing if for wrong edit', () => {
-        const log = new EditLog();
-        const editsProcessed = [];
-        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleLogBaseView, (_, _2, wasCached) => editsProcessed.push(wasCached));
-        const before = viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-        const edit = newEdit([]);
-        log.addLocalEdit(edit);
-        viewer.setKnownEditingResult(newEdit([]), {
-            status: EditStatus.Applied,
-            changes: edit.changes,
-            before,
-            after: arbitraryRevisionView,
-            steps: [],
-        });
-        const after = viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-        expect(editsProcessed).deep.equal([false]);
-        expect(after).not.equal(arbitraryRevisionView);
-    });
-    it('uses known editing result with multiple edits', () => {
-        const log = new EditLog();
-        const editsProcessed = [];
-        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.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-        expect(editsProcessed).deep.equal([false]);
-        log.addLocalEdit(edit2);
-        viewer.setKnownEditingResult(edit2, {
-            status: EditStatus.Applied,
-            changes: edit2.changes,
-            before,
-            after: arbitraryRevisionView,
-            steps: [],
-        });
-        const after = viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-        expect(editsProcessed).deep.equal([false, true]);
-        expect(after).equal(arbitraryRevisionView);
-        log.addLocalEdit(edit3);
-        viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-        expect(editsProcessed).deep.equal([false, true, false]);
-    });
-    it('caches the oldest in memory revision when edits are evicted', async () => {
-        let retainedRevision = 0;
-        const targetEditLogSize = 10;
-        const log = new EditLog(undefined, undefined, undefined, targetEditLogSize, targetEditLogSize * 2);
-        const viewer = getCachingLogViewerAssumeAppliedEdits(log, simpleLogBaseView);
-        viewer.on(CachingLogViewerDiagnosticEvents.RevisionRetained, (revision) => {
-            retainedRevision = revision;
-        });
-        // Add enough edits to the log to start evicting
-        for (let i = 0; i < targetEditLogSize; i++) {
-            const edit = newEdit([]);
-            log.addSequencedEdit(edit, { sequenceNumber: i, referenceSequenceNumber: i - 1 });
-            expect(log.getIndexOfId(edit.id)).equals(i);
-        }
-        expect(log.length)
-            .equals(log.numberOfSequencedEdits)
-            .and.equals(targetEditLogSize, 'Only sequenced edits should be present.');
-        // Add more edits so that the oldest get evicted
-        for (let i = 0; i < targetEditLogSize; i++) {
-            const edit = newEdit([]);
-            const sequenceNumber = targetEditLogSize + i;
-            log.addSequencedEdit(edit, {
-                sequenceNumber,
-                referenceSequenceNumber: sequenceNumber - 1,
-                minimumSequenceNumber: sequenceNumber - 1,
-            });
-        }
-        // Check to see that the revision was retained
-        expect(retainedRevision).to.equal(targetEditLogSize);
-        // Make sure retrieving the latest revision is possible after edit eviction
-        viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-    });
-    describe('Callbacks', () => {
-        function getViewer() {
-            const log = getTestTreeLog(testTree);
-            const events = [];
-            const viewer = new CachingLogViewer(log, simpleLogBaseView, undefined, 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(ChangeInternal.insertTree([testTree.buildLeafInternal()], expectDefined(StablePlaceInternal.atEndOf({
-                label: testTraitLabel,
-                parent: testTree.generateNodeId(),
-            }))));
-            log.addLocalEdit(edit);
-            return edit;
-        }
-        it('processSequencedEditResult is called when a sequenced edit is applied', async () => {
-            const { log, events, viewer } = getViewer();
-            viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-            events.splice(0);
-            // Non-sequenced edit should not trigger a call
-            const invalidEdit = addInvalidEdit(log);
-            viewer.getRevisionViewInMemory(Number.POSITIVE_INFINITY);
-            expect(events.length).equals(0);
-            log.addSequencedEdit(invalidEdit, { sequenceNumber: 3, referenceSequenceNumber: 2 });
-            viewer.getRevisionViewInMemory(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 });
-            viewer.getRevisionViewInMemory(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 });
-            viewer.getRevisionViewInMemory(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 ?? uuidv4());
-            const edit = { changes: [ChangeInternal.setPayload(simpleLogBaseView.root, id)], id };
-            logViewer.log.addSequencedEdit(edit, {
-                sequenceNumber,
-                referenceSequenceNumber: referenceSequenceNumber ?? sequenceNumber - 1,
-            });
-            return edit;
-        }
-        function minimalLogViewer() {
-            return new CachingLogViewer(new EditLog(), simpleLogBaseView);
-        }
-        it('tracks the earliest sequenced edit in the session', () => {
-            const logViewer = minimalLogViewer();
-            expect(logViewer.earliestSequencedEditInMemory()).undefined;
-            // Non-sequenced edit
-            logViewer.log.addLocalEdit({ id: uuidv4(), changes: [] });
-            expect(logViewer.earliestSequencedEditInMemory()).undefined;
-            // First sequenced edit
-            const edit = addFakeEdit(logViewer, 123);
-            const expected = { edit, sequenceNumber: 123 };
-            expect(logViewer.earliestSequencedEditInMemory()).deep.equals(expected);
-            // Non-sequenced edit
-            logViewer.log.addLocalEdit({ id: uuidv4(), changes: [] });
-            expect(logViewer.earliestSequencedEditInMemory()).deep.equals(expected);
-            // Second sequenced edit
-            addFakeEdit(logViewer, 456);
-            expect(logViewer.earliestSequencedEditInMemory()).deep.equals(expected);
-        });
-        it('can provide edit results for sequenced edits', () => {
-            const logViewer = minimalLogViewer();
-            expect(logViewer.getEditResultFromSequenceNumber(42)).undefined;
-            // Non-sequenced edit
-            logViewer.log.addLocalEdit({ id: uuidv4(), changes: [] });
-            expect(logViewer.getEditResultFromSequenceNumber(42)).undefined;
-            // First sequenced edit
-            const edit1 = addFakeEdit(logViewer, 123);
-            expect(logViewer.getEditResultFromSequenceNumber(42)).undefined;
-            const expected1 = {
-                id: edit1.id,
-            };
-            expect(logViewer.getEditResultFromSequenceNumber(123)).contains(expected1);
-            // Check that when no such sequence number exists, the closest earlier edit is returned
-            expect(logViewer.getEditResultFromSequenceNumber(124)).contains(expected1);
-            // Second sequenced edit
-            // Note that this edit is given a greater sequence number than simply incrementing after edit 1.
-            // 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, 456);
-            expect(logViewer.getEditResultFromSequenceNumber(123)).contains(expected1);
-            // Check that when no such sequence number exists, the closest earlier edit is returned
-            expect(logViewer.getEditResultFromSequenceNumber(124)).contains(expected1);
-            const expected2 = {
-                id: edit2.id,
-            };
-            expect(logViewer.getEditResultFromSequenceNumber(456)).contains(expected2);
-            // Check that when no such sequence number exists, the closest earlier edit is returned
-            expect(logViewer.getEditResultFromSequenceNumber(457)).contains(expected2);
-        });
-        it('can provide the reconciliation path for an edit', () => {
-            const logViewer = minimalLogViewer();
-            function expectReconciliationPath(edit, path) {
-                const actual = logViewer.reconciliationPathFromEdit(edit.id);
-                expect(actual.length).equals(path.length);
-                for (let i = 0; i < path.length; ++i) {
-                    expect(actual[i].length).equals(1);
-                    const change = actual[i][0].resolvedChange;
-                    expect(change.payload).equals(path[i].id);
-                }
-            }
-            // Non-sequenced edit
-            const nonSeqEdit = { id: uuidv4(), changes: [] };
-            logViewer.log.addLocalEdit(nonSeqEdit);
-            expectReconciliationPath(nonSeqEdit, []);
-            const edit1 = addFakeEdit(logViewer, 1001);
-            expectReconciliationPath(edit1, []);
-            // Note that this edit is given a greater sequence number than simply incrementing after edit 1.
-            // 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, []);
-            const edit3 = addFakeEdit(logViewer, 3001, 2000);
-            expectReconciliationPath(edit3, [edit2]);
-            const edit4 = addFakeEdit(logViewer, 4001, 2500);
-            expectReconciliationPath(edit4, [edit3]);
-            const edit5 = addFakeEdit(logViewer, 5001, 500);
-            expectReconciliationPath(edit5, [edit1, edit2, edit3, edit4]);
-        });
-    });
-});
-//# sourceMappingURL=LogViewer.tests.js.map