@fluid-internal/presence-runtime 2.102.0 → 2.110.0

package/lib/states/test/schemaValidation/valueManagers.spec.js

@@ -1,782 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { strict as assert } from "node:assert";
-import { EventAndErrorTrackingLogger } from "@fluidframework/test-utils/internal";
-import { describe, it, after, afterEach, before, beforeEach } from "mocha";
-import { useFakeTimers } from "sinon";
-import { StateFactory } from "@fluid-internal/presence-runtime/states";
-import { toOpaqueJson } from "@fluid-internal/presence-runtime/utils";
-import { MockEphemeralRuntime } from "../mockEphemeralRuntime.js";
-import { assertFinalExpectations, attendeeId1, localAttendeeId, connectionId1, initialLocalClientConnectionId, createSpiedValidator, prepareConnectedPresence, } from "../testUtils.js";
-const attendeeUpdate = {
-    "clientToSessionId": {
-        [connectionId1]: {
-            "rev": 0,
-            "timestamp": 0,
-            "value": attendeeId1,
-        },
-    },
-};
-const latestUpdate = {
-    "latest": {
-        [attendeeId1]: {
-            "rev": 1,
-            "timestamp": 0,
-            "value": toOpaqueJson({ x: 1, y: 1, z: 1 }),
-        },
-    },
-};
-const latestMapUpdate = {
-    "latestMap": {
-        [attendeeId1]: {
-            "rev": 1,
-            "items": {
-                "key1": {
-                    "rev": 1,
-                    "timestamp": 0,
-                    "value": toOpaqueJson({ x: 1, y: 1, z: 1 }),
-                },
-                "key2": {
-                    "rev": 1,
-                    "timestamp": 0,
-                    "value": toOpaqueJson({ x: 2, y: 2, z: 2 }),
-                },
-                "invalidKey": {
-                    "rev": 1,
-                    "timestamp": 0,
-                    "value": toOpaqueJson({ x: -1, y: -1, z: -1 }),
-                },
-            },
-        },
-    },
-};
-function datastoreUpdateSignal(sendTimestamp, valueObjectName, metadata) {
-    return {
-        type: "Pres:DatastoreUpdate",
-        content: {
-            sendTimestamp,
-            avgLatency: 20,
-            data: {
-                "system:presence": attendeeUpdate,
-                "s:name:testWorkspace": {
-                    [valueObjectName]: {
-                        [attendeeId1]: metadata,
-                    },
-                },
-            },
-        },
-        clientId: connectionId1,
-    };
-}
-/**
- * Runs a test against a validator by getting the value and matching the resulting data and validator call counts
- * against expectations.
- */
-function runValidatorTest(params) {
-    const initialValue = params.getRemoteValue();
-    assert.equal(params.validatorFunction.callCount, params.expectedCallCount);
-    assert.deepEqual(initialValue, params.expectedValue);
-}
-/**
- * Runs a test against a validator by getting the value multiple times and verifying that the validator is not called
- * multiple times.
- */
-function runMultipleCallsTest(params) {
-    // First call should invoke validator
-    const firstValue = params.getRemoteValue();
-    assert.equal(params.validatorFunction.callCount, 1);
-    assert.deepEqual(firstValue, params.expectedValue);
-    // Subsequent calls should not invoke validator when data is unchanged
-    const secondValue = params.getRemoteValue();
-    assert.equal(params.validatorFunction.callCount, 1);
-    const thirdValue = params.getRemoteValue();
-    assert.equal(params.validatorFunction.callCount, 1);
-    assert.deepEqual(secondValue, params.expectedValue);
-    assert.deepEqual(thirdValue, params.expectedValue);
-}
-describe("Presence/States", () => {
-    describe("Runtime schema validation", () => {
-        const afterCleanUp = [];
-        const initialTime = 1000;
-        function processUpdates(valueManagerUpdates) {
-            const updates = { "system:presence": attendeeUpdate, ...valueManagerUpdates };
-            processSignal([], {
-                type: "Pres:DatastoreUpdate",
-                content: {
-                    sendTimestamp: clock.now - 10,
-                    avgLatency: 20,
-                    data: updates,
-                },
-                clientId: "client1",
-            }, false);
-        }
-        let clock;
-        let logger;
-        let presence;
-        let processSignal;
-        let runtime;
-        let remoteAttendee;
-        let validatorCallExpected;
-        let point3DValidatorFunction;
-        before(async () => {
-            clock = useFakeTimers();
-        });
-        /**
-         * This beforeEach sets up the runtime and presence objects. The `presence` object is owned by attendee2, while
-         * attendee1 acts as a remote attendee for the purposes of the tests.
-         */
-        beforeEach(() => {
-            logger = new EventAndErrorTrackingLogger();
-            runtime = new MockEphemeralRuntime(logger);
-            clock.setSystemTime(initialTime);
-            validatorCallExpected = true;
-            point3DValidatorFunction = createSpiedValidator((d) => {
-                if (validatorCallExpected === "once") {
-                    validatorCallExpected = false;
-                }
-                else {
-                    assert(validatorCallExpected, "point3DValidatorFunction should not be called at this time");
-                }
-                return typeof d === "object" ? d : undefined;
-            });
-            // Create Presence joining session as attendeeId-2. Tests will act as attendee2
-            ({ presence, processSignal } = prepareConnectedPresence(runtime, localAttendeeId, initialLocalClientConnectionId, clock, logger));
-            // Pass a little time (to mimic reality)
-            clock.tick(10);
-            // Process remote client update signal (attendeeId-1 is then part of local client's known session).
-            processUpdates({
-                "s:name:testWorkspace": { ...latestUpdate, ...latestMapUpdate },
-            });
-            // Pass a little time (to mimic reality)
-            clock.tick(10);
-            // Get attendee references
-            remoteAttendee = presence.attendees.getAttendee(attendeeId1);
-        });
-        afterEach(function (done) {
-            clock.reset();
-            point3DValidatorFunction.resetHistory();
-            // If the test passed so far, check final expectations.
-            if (this.currentTest?.state === "passed") {
-                assertFinalExpectations(runtime, logger);
-            }
-            for (const cleanUp of afterCleanUp) {
-                cleanUp();
-            }
-            afterCleanUp.length = 0;
-            done();
-        });
-        after(() => {
-            clock.restore();
-        });
-        describe("Latest validator", () => {
-            let latest;
-            /**
-             * This beforeEach sets up the presence workspace itself and gets a reference to it. It then sets some new data as
-             * attendee1 by processing a datastore update signal.
-             */
-            beforeEach(() => {
-                // Setup workspace initialization signal
-                runtime.signalsExpected.push([
-                    {
-                        type: "Pres:DatastoreUpdate",
-                        content: {
-                            sendTimestamp: clock.now,
-                            avgLatency: 10,
-                            data: {
-                                "system:presence": {
-                                    "clientToSessionId": {
-                                        [initialLocalClientConnectionId]: {
-                                            "rev": 0,
-                                            "timestamp": initialTime,
-                                            "value": localAttendeeId,
-                                        },
-                                    },
-                                },
-                                "s:name:testWorkspace": {
-                                    "latest": {
-                                        [localAttendeeId]: {
-                                            "rev": 0,
-                                            "timestamp": clock.now,
-                                            "value": toOpaqueJson({ x: 0, y: 0, z: 0 }),
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ]);
-                const stateWorkspace = presence.states.getWorkspace("name:testWorkspace", {
-                    latest: StateFactory.latest({
-                        local: { x: 0, y: 0, z: 0 },
-                        validator: point3DValidatorFunction,
-                        settings: { allowableUpdateLatencyMs: 0 },
-                    }),
-                });
-                latest = stateWorkspace.states.latest;
-                // Process a valid update signal with Point3D data
-                processSignal([], {
-                    type: "Pres:DatastoreUpdate",
-                    content: {
-                        sendTimestamp: clock.now - 10,
-                        avgLatency: 20,
-                        data: {
-                            "system:presence": attendeeUpdate,
-                            "s:name:testWorkspace": {
-                                "latest": {
-                                    [attendeeId1]: {
-                                        "rev": 2,
-                                        "timestamp": clock.now - 10,
-                                        "value": toOpaqueJson({ x: 10, y: 20, z: 30 }),
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    clientId: "client1",
-                }, false);
-            });
-            describe("is not called", () => {
-                it("by .getRemote()", () => {
-                    // Calling getRemote should not invoke the validator (only a value read will).
-                    latest.getRemote(remoteAttendee);
-                    assert.equal(point3DValidatorFunction.callCount, 0);
-                });
-                it("by .getRemotes()", () => {
-                    for (const _ of latest.getRemotes()) {
-                        assert.equal(point3DValidatorFunction.callCount, 0);
-                    }
-                });
-                it("when accessing .local", () => {
-                    assert.equal(point3DValidatorFunction.callCount, 0, "initial call count is wrong");
-                    assert.deepEqual(latest.local, { x: 0, y: 0, z: 0 });
-                    assert.equal(point3DValidatorFunction.callCount, 0, "validator was called on local data");
-                });
-                it("when remote data is updated", () => {
-                    const remoteData = latest.getRemote(remoteAttendee);
-                    // Should call validator
-                    runValidatorTest({
-                        getRemoteValue: () => remoteData.value(),
-                        expectedCallCount: 1,
-                        expectedValue: { x: 10, y: 20, z: 30 },
-                        validatorFunction: point3DValidatorFunction,
-                    });
-                    // Send updated data from remote client
-                    const timestamp = clock.now - 15;
-                    processSignal([], datastoreUpdateSignal(timestamp, "latest", {
-                        "rev": 3,
-                        timestamp,
-                        "value": toOpaqueJson({ x: 50, y: 60, z: 70 }),
-                    }), false);
-                    // Validator is not called by remote update
-                    assert.equal(point3DValidatorFunction.callCount, 1);
-                });
-            });
-            describe("is called", () => {
-                it("on first .value() call", () => {
-                    const remoteData = latest.getRemote(remoteAttendee);
-                    runValidatorTest({
-                        getRemoteValue: () => remoteData.value(),
-                        expectedCallCount: 1,
-                        expectedValue: { x: 10, y: 20, z: 30 },
-                        validatorFunction: point3DValidatorFunction,
-                    });
-                });
-                it("only once for multiple .value() calls in series and .value() always returns same value", () => {
-                    const remoteData = latest.getRemote(remoteAttendee);
-                    runMultipleCallsTest({
-                        getRemoteValue: () => remoteData.value(),
-                        expectedValue: { x: 10, y: 20, z: 30 },
-                        validatorFunction: point3DValidatorFunction,
-                    });
-                });
-                it("on .value() call after remote data has changed", () => {
-                    // Get the remote data and read it, verify that the validator is called once.
-                    const remoteData = latest.getRemote(remoteAttendee);
-                    assert.deepEqual(remoteData.value(), { x: 10, y: 20, z: 30 });
-                    assert.equal(point3DValidatorFunction.callCount, 1, "first call count is wrong");
-                    // Send updated data from remote client
-                    const timestamp = clock.now - 15;
-                    processSignal([], datastoreUpdateSignal(timestamp, "latest", {
-                        "rev": 3,
-                        timestamp,
-                        "value": toOpaqueJson({ x: 50, y: 60, z: 70 }),
-                    }), false);
-                    // Reading the remote value should cause the validator to be called a second time since the data has been changed.
-                    const data2 = latest.getRemote(remoteAttendee);
-                    assert.deepEqual(data2.value(), { x: 50, y: 60, z: 70 }, "updated remote value is wrong");
-                    assert.equal(point3DValidatorFunction.callCount, 2, "validator should be called twice");
-                });
-                it("on .value() call when remote data changes from valid to invalid", () => {
-                    // Get the remote data and read it, verify that the validator is called once.
-                    const remoteData = latest.getRemote(remoteAttendee);
-                    assert.deepEqual(remoteData.value(), { x: 10, y: 20, z: 30 });
-                    assert.equal(point3DValidatorFunction.callCount, 1, "first call count is wrong");
-                    // Send invalid data from remote client
-                    const timestamp = clock.now - 15;
-                    processSignal([], datastoreUpdateSignal(timestamp, "latest", {
-                        "rev": 3,
-                        timestamp,
-                        "value": toOpaqueJson("invalid"),
-                    }), false);
-                    // Reading the remote value should cause the validator to be called a second time and return undefined
-                    const data2 = latest.getRemote(remoteAttendee);
-                    assert.equal(data2.value(), undefined, "invalid data should return undefined");
-                    assert.equal(point3DValidatorFunction.callCount, 2, "validator should be called twice");
-                });
-                it("on .value() call when remote data changes from invalid to valid", () => {
-                    // First send invalid data
-                    let timestamp = clock.now - 15;
-                    processSignal([], datastoreUpdateSignal(timestamp, "latest", {
-                        "rev": 3,
-                        timestamp,
-                        "value": toOpaqueJson("invalid"),
-                    }), false);
-                    // Get the remote data and read it, verify that the validator is called once and returns undefined
-                    const remoteData = latest.getRemote(remoteAttendee);
-                    assert.equal(remoteData.value(), undefined);
-                    assert.equal(point3DValidatorFunction.callCount, 1, "first call count is wrong");
-                    // Send valid data from remote client
-                    timestamp += 10;
-                    processSignal([], datastoreUpdateSignal(timestamp, "latest", {
-                        "rev": 4,
-                        timestamp,
-                        "value": toOpaqueJson({ x: 100, y: 200, z: 300 }),
-                    }), false);
-                    // Reading the remote value should cause the validator to be called a second time and return valid data
-                    const data2 = latest.getRemote(remoteAttendee);
-                    assert.deepEqual(data2.value(), { x: 100, y: 200, z: 300 }, "valid data should be returned");
-                    assert.equal(point3DValidatorFunction.callCount, 2, "validator should be called twice");
-                });
-                it("on .value() call when remote data changes from invalid to invalid", () => {
-                    // First send invalid data
-                    let timestamp = clock.now - 15;
-                    processSignal([], datastoreUpdateSignal(timestamp, "latest", {
-                        "rev": 3,
-                        timestamp,
-                        "value": toOpaqueJson("invalid"),
-                    }), false);
-                    // Get the remote data and read it, verify that the validator is called once and returns undefined
-                    const remoteData = latest.getRemote(remoteAttendee);
-                    assert.equal(remoteData.value(), undefined);
-                    assert.equal(point3DValidatorFunction.callCount, 1, "first call count is wrong");
-                    // Send different invalid data from remote client
-                    timestamp += 10;
-                    processSignal([], datastoreUpdateSignal(timestamp, "latest", {
-                        "rev": 4,
-                        timestamp,
-                        "value": toOpaqueJson("also-invalid"),
-                    }), false);
-                    // Reading the remote value should cause the validator to be called a second time and still return undefined
-                    const data2 = latest.getRemote(remoteAttendee);
-                    assert.equal(data2.value(), undefined, "invalid data should return undefined");
-                    assert.equal(point3DValidatorFunction.callCount, 2, "validator should be called twice");
-                });
-            });
-        });
-        describe("LatestMap with validation", () => {
-            let latestMap;
-            let keyValidatorCallExpectedCount;
-            function keyValidatorFunction(key) {
-                assert(keyValidatorCallExpectedCount > 0, "keyValidatorFunction should not be called at this time");
-                keyValidatorCallExpectedCount--;
-                return key.startsWith("key");
-            }
-            /**
-             * This beforeEach sets up the presence workspace itself and gets a
-             * reference to it.
-             */
-            beforeEach(() => {
-                keyValidatorCallExpectedCount = 0;
-                // workspace setup's initialization signal
-                runtime.signalsExpected.push([
-                    {
-                        "type": "Pres:DatastoreUpdate",
-                        "content": {
-                            "sendTimestamp": clock.now,
-                            "avgLatency": 10,
-                            "data": {
-                                "system:presence": {
-                                    "clientToSessionId": {
-                                        [initialLocalClientConnectionId]: {
-                                            "rev": 0,
-                                            "timestamp": initialTime,
-                                            "value": localAttendeeId,
-                                        },
-                                    },
-                                },
-                                "s:name:testWorkspace": {
-                                    "latestMap": {
-                                        [localAttendeeId]: {
-                                            "rev": 0,
-                                            "items": {
-                                                "key1": {
-                                                    "rev": 0,
-                                                    "timestamp": clock.now,
-                                                    "value": toOpaqueJson({ "x": 0, "y": 0, "z": 0 }),
-                                                },
-                                                "key2": {
-                                                    "rev": 0,
-                                                    "timestamp": clock.now,
-                                                    "value": toOpaqueJson({ "x": 0, "y": 0, "z": 0 }),
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ]);
-                const stateWorkspace = presence.states.getWorkspace("name:testWorkspace", {
-                    latestMap: StateFactory.latestMap({
-                        local: { "key1": { x: 0, y: 0, z: 0 }, "key2": { x: 0, y: 0, z: 0 } },
-                        validator: point3DValidatorFunction,
-                        keyValidator: keyValidatorFunction,
-                        settings: { allowableUpdateLatencyMs: 0 },
-                    }),
-                });
-                latestMap = stateWorkspace.states.latestMap;
-            });
-            function sendInvalidData(key = "key1") {
-                keyValidatorCallExpectedCount = 1;
-                const timestamp = clock.now - 15;
-                processSignal([], datastoreUpdateSignal(timestamp, "latestMap", {
-                    "rev": 2,
-                    "items": {
-                        [key]: {
-                            "rev": 2,
-                            timestamp,
-                            "value": toOpaqueJson("invalid"),
-                        },
-                    },
-                }), false);
-                assert.equal(keyValidatorCallExpectedCount, 0);
-            }
-            describe("no validator is called", () => {
-                beforeEach(() => {
-                    validatorCallExpected = false;
-                });
-                it("when reading local key value", () => {
-                    // Act
-                    const localData = latestMap.local.get("key1");
-                    // Verify
-                    assert.equal(point3DValidatorFunction.callCount, 0);
-                    // double check local data
-                    assert.deepEqual(localData, { x: 0, y: 0, z: 0 });
-                });
-                it("when writing local key value", () => {
-                    // Setup
-                    runtime.signalsExpected.push([
-                        {
-                            "type": "Pres:DatastoreUpdate",
-                            "content": {
-                                "sendTimestamp": clock.now,
-                                "avgLatency": 10,
-                                "data": {
-                                    "system:presence": {
-                                        "clientToSessionId": {
-                                            [initialLocalClientConnectionId]: {
-                                                "rev": 0,
-                                                "timestamp": initialTime,
-                                                "value": localAttendeeId,
-                                            },
-                                        },
-                                    },
-                                    "s:name:testWorkspace": {
-                                        "latestMap": {
-                                            [localAttendeeId]: {
-                                                "rev": 1,
-                                                "items": {
-                                                    "key1": {
-                                                        "rev": 1,
-                                                        "timestamp": clock.now,
-                                                        "value": toOpaqueJson({ "x": 0, "y": 1, "z": 2 }),
-                                                    },
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    ]);
-                    // Act
-                    latestMap.local.set("key1", { x: 0, y: 1, z: 2 });
-                    // Verify
-                    assert.equal(point3DValidatorFunction.callCount, 0);
-                });
-            });
-            it("update with invalid key invokes key validator per key and does not raise events", () => {
-                // Setup
-                for (const event of [
-                    "remoteUpdated",
-                    "remoteItemUpdated",
-                    "remoteItemRemoved",
-                ]) {
-                    afterCleanUp.push(latestMap.events.on(event, () => {
-                        assert.fail(`${event} event should not be raised for invalid key`);
-                    }));
-                }
-                keyValidatorCallExpectedCount = 1;
-                // Act
-                sendInvalidData("invalidKey");
-                // Verify
-                assert.equal(keyValidatorCallExpectedCount, 0); // all expected calls were made
-                assert.equal(point3DValidatorFunction.callCount, 0);
-            });
-            /**
-             * Sets validator call expectations and gets remote value data.
-             * @returns `latestMap.getRemote(remoteAttendee)`
-             * @remarks
-             * `validatorCallExpected` will be `false` and `keyValidatorCallExpectedCount`
-             * will be `0` after the call.
-             */
-            function getRemoteValue() {
-                validatorCallExpected = false;
-                keyValidatorCallExpectedCount = 3;
-                const remoteData = latestMap.getRemote(remoteAttendee);
-                assert.equal(keyValidatorCallExpectedCount, 0);
-                return remoteData;
-            }
-            it(".getRemote call invokes key validator per key but not value validator", () => {
-                // Setup and Act
-                getRemoteValue();
-                // Verify
-                assert.equal(keyValidatorCallExpectedCount, 0); // all expected calls were made
-                assert.equal(point3DValidatorFunction.callCount, 0);
-            });
-            describe("remote value map", () => {
-                it(".get() does not call any validator", () => {
-                    // Setup
-                    const remoteData = getRemoteValue();
-                    // Act
-                    remoteData.get("key1");
-                    // Verify
-                    assert.equal(point3DValidatorFunction.callCount, 0);
-                });
-                it(".forEach() iteration does not call any validator", () => {
-                    // Setup
-                    const remoteData = getRemoteValue();
-                    let counter = 0;
-                    const expectedValues = [
-                        ["key1", { x: 1, y: 1, z: 1 }],
-                        ["key2", { x: 2, y: 2, z: 2 }],
-                    ];
-                    // Act
-                    // eslint-disable-next-line unicorn/no-array-for-each -- forEach is being tested here
-                    remoteData.forEach((_value, key) => {
-                        // Verify
-                        assert.equal(point3DValidatorFunction.callCount, 0, "call count is wrong");
-                        assert.equal(key, expectedValues[counter][0]);
-                        counter++;
-                    });
-                    // Make sure forEach iterated through all keys
-                    assert.equal(counter, expectedValues.length, "counter should match expected values length");
-                });
-                describe("value validator is called", () => {
-                    for (const { desc, setup, expectedValue } of [
-                        {
-                            desc: "for valid value",
-                            setup: () => { },
-                            expectedValue: { x: 1, y: 1, z: 1 },
-                        },
-                        {
-                            desc: "for invalid value",
-                            setup: sendInvalidData,
-                            expectedValue: undefined,
-                        },
-                    ]) {
-                        it(`once when key.value() is called ${desc}`, () => {
-                            // Setup
-                            setup();
-                            const remoteData = getRemoteValue();
-                            validatorCallExpected = "once";
-                            // Act
-                            runValidatorTest({
-                                getRemoteValue: () => remoteData.get("key1")?.value(),
-                                expectedCallCount: 1,
-                                expectedValue,
-                                validatorFunction: point3DValidatorFunction,
-                            });
-                        });
-                        it(`only once for multiple key.value() calls in series and .value() always returned same result ${desc}`, () => {
-                            // Setup
-                            setup();
-                            const remoteData = getRemoteValue();
-                            validatorCallExpected = "once";
-                            // Act
-                            runMultipleCallsTest({
-                                getRemoteValue: () => remoteData.get("key1")?.value(),
-                                expectedValue,
-                                validatorFunction: point3DValidatorFunction,
-                            });
-                        });
-                        it(`exactly once for each value's .value() calls in .forEach() and .value() always returns same result ${desc}`, () => {
-                            // Setup
-                            setup();
-                            const remoteData = getRemoteValue();
-                            let counter = 0;
-                            const expectedValues = [
-                                // only key1 value might be altered by the setup function
-                                ["key1", expectedValue],
-                                // key2 value will always be the valid
-                                ["key2", { x: 2, y: 2, z: 2 }],
-                            ];
-                            // Act
-                            // eslint-disable-next-line unicorn/no-array-for-each -- forEach is being tested here
-                            remoteData.forEach((value, key) => {
-                                assert.equal(key, expectedValues[counter][0]);
-                                // reset call expectations/count for each iteration
-                                validatorCallExpected = "once";
-                                point3DValidatorFunction.callCount = 0;
-                                // Act - first call
-                                const valueData = value?.value();
-                                // Verify
-                                assert.equal(point3DValidatorFunction.callCount, 1, "validator was not called");
-                                // double check value
-                                assert.deepEqual(valueData, expectedValues[counter][1], `value at key "${key}" is wrong`);
-                                // Act - second call
-                                // Access value a second time; should not affect validator call count
-                                const valueDataRedux = value?.value();
-                                // Verify
-                                assert.equal(point3DValidatorFunction.callCount, 1, "validator was called a second time");
-                                assert.strictEqual(valueDataRedux, valueData, `value at key "${key}" is wrong`);
-                                counter++;
-                            });
-                            // Make sure forEach iterated through all keys
-                            assert.equal(counter, expectedValues.length, "counter should match expected values length");
-                        });
-                    }
-                    for (const { desc, setup, expectedInitialValue, newData, expectedValue } of [
-                        {
-                            desc: "from valid to different valid value",
-                            setup: () => { },
-                            expectedInitialValue: { x: 1, y: 1, z: 1 },
-                            newData: { x: 4, y: 4, z: 4 },
-                            expectedValue: { x: 4, y: 4, z: 4 },
-                        },
-                        {
-                            desc: "from valid to same valid value",
-                            setup: () => { },
-                            expectedInitialValue: { x: 1, y: 1, z: 1 },
-                            newData: { x: 1, y: 1, z: 1 },
-                            expectedValue: { x: 1, y: 1, z: 1 },
-                        },
-                        {
-                            desc: "from valid to invalid value",
-                            setup: () => { },
-                            expectedInitialValue: { x: 1, y: 1, z: 1 },
-                            newData: "invalid",
-                            expectedValue: undefined,
-                        },
-                        {
-                            desc: "from invalid to valid value",
-                            setup: sendInvalidData,
-                            expectedInitialValue: undefined,
-                            newData: { x: 4, y: 4, z: 4 },
-                            expectedValue: { x: 4, y: 4, z: 4 },
-                        },
-                        {
-                            desc: "from invalid to invalid value",
-                            setup: sendInvalidData,
-                            expectedInitialValue: undefined,
-                            newData: "invalid",
-                            expectedValue: undefined,
-                        },
-                    ]) {
-                        it(`during .value() call after remote key data has changed ${desc}`, () => {
-                            // Setup
-                            setup();
-                            const originalMap = getRemoteValue();
-                            validatorCallExpected = "once";
-                            // Get the remote data and read it, expect that the validator is called once.
-                            const key1Value = originalMap.get("key1")?.value();
-                            assert.equal(point3DValidatorFunction.callCount, 1, "first call count is wrong");
-                            assert.deepEqual(key1Value, expectedInitialValue);
-                            // Reset call count for next verification
-                            point3DValidatorFunction.callCount = 0;
-                            // Process updated key data from remote client
-                            keyValidatorCallExpectedCount = 1;
-                            const timestamp = clock.now - 15;
-                            processSignal([], datastoreUpdateSignal(timestamp, "latestMap", {
-                                "rev": 3,
-                                "items": {
-                                    "key1": {
-                                        "rev": 3,
-                                        timestamp,
-                                        "value": toOpaqueJson(newData),
-                                    },
-                                },
-                            }), false);
-                            assert.equal(keyValidatorCallExpectedCount, 0);
-                            // Verify no call yet
-                            assert.equal(point3DValidatorFunction.callCount, 0, "call count after update is wrong");
-                            // Reading the remote value should cause the validator to be
-                            // called since the data has been changed.
-                            const updatedMap = getRemoteValue();
-                            validatorCallExpected = "once";
-                            // Act - read updated key value
-                            const updatedKey1Value = updatedMap.get("key1")?.value();
-                            // Verify
-                            assert.equal(point3DValidatorFunction.callCount, 1, "validator should be called twice");
-                            assert.deepEqual(updatedKey1Value, expectedValue, "updated remote key value is wrong");
-                        });
-                    }
-                });
-            });
-            // Note this block is after "value validator is called" as it is only valid when those tests are passing.
-            describe("no validator is called", () => {
-                it("during .value() call for unchanged keys", () => {
-                    // Setup
-                    keyValidatorCallExpectedCount = 3;
-                    const originalMap = latestMap.getRemote(remoteAttendee);
-                    assert.equal(keyValidatorCallExpectedCount, 0);
-                    validatorCallExpected = "once";
-                    // Read key1 value - should call validator once
-                    const key1Value = originalMap.get("key1")?.value();
-                    assert.equal(point3DValidatorFunction.callCount, 1, "validator should be called once for key1");
-                    assert.deepEqual(key1Value, { x: 1, y: 1, z: 1 });
-                    // Update key2 (different key) with new data, keeping key1 unchanged
-                    keyValidatorCallExpectedCount = 1;
-                    const timestamp = clock.now - 15;
-                    processSignal([], datastoreUpdateSignal(timestamp, "latestMap", {
-                        "rev": 2,
-                        "items": {
-                            "key2": {
-                                "rev": 2,
-                                timestamp,
-                                "value": toOpaqueJson({ "x": 4, "y": 4, "z": 4 }),
-                            },
-                        },
-                    }), false);
-                    assert.equal(keyValidatorCallExpectedCount, 0);
-                    const updatedMap = getRemoteValue();
-                    const key1Redux = updatedMap.get("key1");
-                    assert.ok(key1Redux);
-                    assert.equal(keyValidatorCallExpectedCount, 0);
-                    assert.equal(point3DValidatorFunction.callCount, 1);
-                    // Act & Verify
-                    // Read key1 value (again) but from updated map - should NOT call validator again since key1 data hasn't changed
-                    const key1ValueRedux = key1Redux.value();
-                    assert.equal(point3DValidatorFunction.callCount, 1, "validator should still be called only once for key1");
-                    assert.strictEqual(key1ValueRedux, key1Value, "key1 value should remain unchanged");
-                    // Test verification
-                    validatorCallExpected = true;
-                    point3DValidatorFunction.callCount = 0;
-                    // key2 should have been updated; so, reading key2 value from
-                    // original map and updated map should both result in call
-                    // count increases. Also check for updated value.
-                    let key2Value = originalMap.get("key2")?.value();
-                    assert.equal(point3DValidatorFunction.callCount, 1, "validator should be called once for original key2 value read");
-                    assert.deepEqual(key2Value, { "x": 2, "y": 2, "z": 2 }, "key2 value from original map should be unchanged");
-                    key2Value = updatedMap.get("key2")?.value();
-                    assert.equal(point3DValidatorFunction.callCount, 2, "validator should be called second time for updated key2 value read");
-                    assert.deepEqual(key2Value, { "x": 4, "y": 4, "z": 4 }, "key2 should have updated value");
-                });
-            });
-        });
-    });
-});
-//# sourceMappingURL=valueManagers.spec.js.map