@fluid-internal/presence-runtime 2.93.0

package/lib/runtime/test/presenceDatastoreManager.spec.js

@@ -0,0 +1,616 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { strict as assert } from "node:assert";
+import { validateAssertionError } from "@fluidframework/test-runtime-utils/internal";
+import { EventAndErrorTrackingLogger } from "@fluidframework/test-utils/internal";
+import { useFakeTimers, spy } from "sinon";
+import { assertFinalExpectations, attendeeId1, initialLocalClientConnectionId, localAttendeeId, createSpecificAttendeeId, MockEphemeralRuntime, prepareConnectedPresence, } from "@fluid-internal/presence-runtime/internal/test-utils";
+import { toOpaqueJson } from "@fluid-internal/presence-runtime/utils";
+import { broadcastJoinResponseDelaysMs } from "../presenceDatastoreManager.js";
+import { createPresenceManager } from "../presenceManager.js";
+const attendee0SystemWorkspaceDatastore = {
+    "clientToSessionId": {
+        ["client0"]: {
+            "rev": 0,
+            "timestamp": 0,
+            "value": createSpecificAttendeeId("attendeeId-0"),
+        },
+    },
+};
+const attendee4SystemWorkspaceDatastore = {
+    "clientToSessionId": {
+        ["client4"]: {
+            "rev": 0,
+            "timestamp": 700,
+            "value": createSpecificAttendeeId("attendeeId-4"),
+        },
+    },
+};
+const attendee5SystemWorkspaceDatastore = {
+    "clientToSessionId": {
+        ["client5"]: {
+            "rev": 0,
+            "timestamp": 800,
+            "value": createSpecificAttendeeId("attendeeId-5"),
+        },
+    },
+};
+describe("Presence/Runtime", () => {
+    describe("protocol handling", () => {
+        let runtime;
+        let logger;
+        const initialTime = 1000;
+        let clock;
+        before(async () => {
+            clock = useFakeTimers();
+        });
+        beforeEach(() => {
+            logger = new EventAndErrorTrackingLogger();
+            runtime = new MockEphemeralRuntime(logger);
+            clock.setSystemTime(initialTime);
+        });
+        afterEach(function (done) {
+            clock.reset();
+            // If the test passed so far, check final expectations.
+            if (this.currentTest?.state === "passed") {
+                assertFinalExpectations(runtime, logger);
+            }
+            done();
+        });
+        after(() => {
+            clock.restore();
+        });
+        it("does not signal when disconnected during initialization", () => {
+            // Act & Verify
+            createPresenceManager(runtime);
+        });
+        it("sends join when connected during initialization", () => {
+            // Setup, Act (call to createPresenceManager), & Verify (post createPresenceManager call)
+            prepareConnectedPresence(runtime, localAttendeeId, initialLocalClientConnectionId, clock, logger);
+        });
+        describe("handles ClientJoin", () => {
+            let processSignal;
+            beforeEach(() => {
+                ({ processSignal } = prepareConnectedPresence(runtime, localAttendeeId, initialLocalClientConnectionId, clock, logger));
+                // Pass a little time (to mimic reality)
+                clock.tick(10);
+            });
+            function joinClients(updateProviders, delayToJoinClient5) {
+                // Join client4
+                processSignal([], {
+                    type: "Pres:ClientJoin",
+                    content: {
+                        sendTimestamp: clock.now - 50,
+                        avgLatency: 50,
+                        data: {
+                            "system:presence": attendee4SystemWorkspaceDatastore,
+                        },
+                        updateProviders,
+                    },
+                    clientId: "client4",
+                }, false);
+                if (delayToJoinClient5 !== undefined) {
+                    // Advance clock to delay joining client5
+                    clock.tick(delayToJoinClient5);
+                    // Join client5
+                    processSignal([], {
+                        type: "Pres:ClientJoin",
+                        content: {
+                            sendTimestamp: clock.now - 50,
+                            avgLatency: 50,
+                            data: {
+                                "system:presence": attendee5SystemWorkspaceDatastore,
+                            },
+                            updateProviders,
+                        },
+                        clientId: "client5",
+                    }, false);
+                }
+            }
+            function processClient0ResponseForClient4() {
+                // Setup
+                // client 0 handles client 4 join
+                processSignal([], {
+                    type: "Pres:DatastoreUpdate",
+                    content: {
+                        "avgLatency": 10,
+                        "data": {
+                            "system:presence": {
+                                "clientToSessionId": {
+                                    ...attendee0SystemWorkspaceDatastore.clientToSessionId,
+                                    ...attendee4SystemWorkspaceDatastore.clientToSessionId,
+                                },
+                            },
+                        },
+                        "isComplete": true,
+                        "joinResponseFor": ["client4"],
+                        "sendTimestamp": clock.now - 10,
+                    },
+                    clientId: "client0",
+                }, false);
+            }
+            it(`when preferred responder ... with broadcast after ${broadcastJoinResponseDelaysMs.namedResponder}ms`, () => {
+                // Setup
+                const updateTime = clock.now + broadcastJoinResponseDelaysMs.namedResponder;
+                // #region Part 1 (no response)
+                // Act
+                // join clients 4 and 5
+                joinClients([initialLocalClientConnectionId], broadcastJoinResponseDelaysMs.namedResponder / 2);
+                // Advance to one tick before expected response time
+                clock.tick(updateTime - 1 - clock.now);
+                // #endregion
+                // #region Part 2 (response after delay)
+                // Setup
+                logger.registerExpectedEvent({
+                    eventName: "Presence:JoinResponse",
+                    details: JSON.stringify({
+                        type: "broadcastAll",
+                        attendeeId: localAttendeeId,
+                        connectionId: initialLocalClientConnectionId,
+                        primaryResponses: JSON.stringify(["client4", "client5"]),
+                        secondaryResponses: JSON.stringify([]),
+                    }),
+                });
+                runtime.signalsExpected.push([
+                    {
+                        type: "Pres:DatastoreUpdate",
+                        content: {
+                            "avgLatency": 10,
+                            "data": {
+                                "system:presence": {
+                                    "clientToSessionId": {
+                                        ...attendee4SystemWorkspaceDatastore.clientToSessionId,
+                                        ...attendee5SystemWorkspaceDatastore.clientToSessionId,
+                                        [initialLocalClientConnectionId]: {
+                                            "rev": 0,
+                                            "timestamp": initialTime,
+                                            "value": localAttendeeId,
+                                        },
+                                    },
+                                },
+                            },
+                            "isComplete": true,
+                            "joinResponseFor": ["client4", "client5"],
+                            "sendTimestamp": clock.now + 1,
+                        },
+                    },
+                ]);
+                // Act
+                clock.tick(1);
+                // Verify
+                assertFinalExpectations(runtime, logger);
+                // #endregion
+            });
+            describe("when NOT preferred responder", () => {
+                it("and no other responses ... with broadcast after delay", () => {
+                    // Setup
+                    const responseOrder = 2;
+                    // 3 * named length (client0 and client1) + quorum sequence order (third -> 2)
+                    const responderIndex = 3 * 2 + responseOrder;
+                    const updateTime = clock.now +
+                        broadcastJoinResponseDelaysMs.namedResponder +
+                        broadcastJoinResponseDelaysMs.backupResponderIncrement * responderIndex;
+                    // #region Part 1 (no response)
+                    // Act
+                    // join client 4
+                    joinClients(["client0", "client1"], undefined);
+                    clock.tick(updateTime - clock.now - 1);
+                    // #endregion
+                    // #region Part 2 (response after delay)
+                    // Setup
+                    logger.registerExpectedEvent({
+                        eventName: "Presence:JoinResponse",
+                        details: JSON.stringify({
+                            type: "broadcastAll",
+                            attendeeId: localAttendeeId,
+                            connectionId: initialLocalClientConnectionId,
+                            primaryResponses: JSON.stringify([]),
+                            secondaryResponses: JSON.stringify([["client4", responseOrder]]),
+                        }),
+                    });
+                    runtime.signalsExpected.push([
+                        {
+                            type: "Pres:DatastoreUpdate",
+                            content: {
+                                "avgLatency": 10,
+                                "data": {
+                                    "system:presence": {
+                                        "clientToSessionId": {
+                                            ...attendee4SystemWorkspaceDatastore.clientToSessionId,
+                                            [initialLocalClientConnectionId]: {
+                                                "rev": 0,
+                                                "timestamp": initialTime,
+                                                "value": localAttendeeId,
+                                            },
+                                        },
+                                    },
+                                },
+                                "isComplete": true,
+                                "joinResponseFor": ["client4"],
+                                "sendTimestamp": clock.now + 1,
+                            },
+                        },
+                    ]);
+                    // Act
+                    clock.tick(1);
+                    // Verify
+                    assertFinalExpectations(runtime, logger);
+                    // #endregion
+                });
+                it("and other has fully responded ... without broadcast", () => {
+                    // Setup
+                    // join client 4
+                    joinClients(["client0", "client1"], undefined);
+                    clock.tick(broadcastJoinResponseDelaysMs.namedResponder);
+                    // Act
+                    // client 0 handles client 4 join
+                    processClient0ResponseForClient4();
+                    clock.runAll();
+                    // Verify
+                    assertFinalExpectations(runtime, logger);
+                });
+                it("and other has partially responded ... with broadcast after delay", () => {
+                    // Setup
+                    const responseOrder = 2;
+                    // 3 * named length (client0 and client1) + quorum sequence order (third -> 2)
+                    const responderIndex = 3 * 2 + responseOrder;
+                    const client4ResponseDelay = broadcastJoinResponseDelaysMs.namedResponder +
+                        broadcastJoinResponseDelaysMs.backupResponderIncrement * responderIndex;
+                    const client4UpdateTime = clock.now + client4ResponseDelay;
+                    const delayToJoinClient5 = client4ResponseDelay / 2;
+                    const client5UpdateTime = client4UpdateTime + delayToJoinClient5;
+                    // join clients 4 and 5
+                    joinClients(["client0", "client1"], delayToJoinClient5);
+                    clock.tick(client4UpdateTime - clock.now - 1);
+                    // client 0 handles client 4 join
+                    processClient0ResponseForClient4();
+                    clock.tick(client5UpdateTime - clock.now - 1);
+                    logger.registerExpectedEvent({
+                        eventName: "Presence:JoinResponse",
+                        details: JSON.stringify({
+                            type: "broadcastAll",
+                            attendeeId: localAttendeeId,
+                            connectionId: initialLocalClientConnectionId,
+                            primaryResponses: JSON.stringify([]),
+                            secondaryResponses: JSON.stringify([["client5", responseOrder]]),
+                        }),
+                    });
+                    runtime.signalsExpected.push([
+                        {
+                            type: "Pres:DatastoreUpdate",
+                            content: {
+                                "avgLatency": 10,
+                                "data": {
+                                    "system:presence": {
+                                        "clientToSessionId": {
+                                            ...attendee0SystemWorkspaceDatastore.clientToSessionId,
+                                            ...attendee4SystemWorkspaceDatastore.clientToSessionId,
+                                            ...attendee5SystemWorkspaceDatastore.clientToSessionId,
+                                            [initialLocalClientConnectionId]: {
+                                                "rev": 0,
+                                                "timestamp": initialTime,
+                                                "value": localAttendeeId,
+                                            },
+                                        },
+                                    },
+                                },
+                                "isComplete": true,
+                                // Only responding for client5 (client4 has been handled)
+                                "joinResponseFor": ["client5"],
+                                "sendTimestamp": clock.now + 1,
+                            },
+                        },
+                    ]);
+                    // Act
+                    clock.tick(1);
+                    // Verify
+                    assertFinalExpectations(runtime, logger);
+                    // #endregion
+                });
+            });
+        });
+        describe("receiving DatastoreUpdate", () => {
+            let presence;
+            let processSignal;
+            const systemWorkspaceUpdate = {
+                "clientToSessionId": {
+                    "client1": {
+                        "rev": 0,
+                        "timestamp": 0,
+                        "value": attendeeId1,
+                    },
+                },
+            };
+            const statesWorkspaceUpdate = {
+                "latest": {
+                    [attendeeId1]: {
+                        "rev": 1,
+                        "timestamp": 0,
+                        "value": toOpaqueJson({}),
+                    },
+                },
+            };
+            const notificationsWorkspaceUpdate = {
+                "testEvents": {
+                    [attendeeId1]: {
+                        "rev": 0,
+                        "timestamp": 0,
+                        "value": toOpaqueJson({}),
+                        "ignoreUnmonitored": true,
+                    },
+                },
+            };
+            beforeEach(() => {
+                ({ presence, processSignal } = prepareConnectedPresence(runtime, localAttendeeId, initialLocalClientConnectionId, clock, logger));
+                // Pass a little time (to mimic reality)
+                clock.tick(10);
+            });
+            it("with unregistered States workspace emits 'workspaceActivated'", () => {
+                // Setup
+                const listener = spy();
+                presence.events.on("workspaceActivated", listener);
+                // Act
+                processSignal([], {
+                    type: "Pres:DatastoreUpdate",
+                    content: {
+                        sendTimestamp: clock.now - 10,
+                        avgLatency: 20,
+                        data: {
+                            "system:presence": systemWorkspaceUpdate,
+                            "s:name:testStateWorkspace": statesWorkspaceUpdate,
+                        },
+                    },
+                    clientId: "client1",
+                }, false);
+                // Verify
+                assert.strictEqual(listener.calledOnce, true);
+                assert.strictEqual(listener.calledWith("name:testStateWorkspace", "States"), true);
+            });
+            it("with unregistered Notifications workspace 'workspaceActivated'", () => {
+                // Setup
+                const listener = spy();
+                presence.events.on("workspaceActivated", listener);
+                // Act
+                processSignal([], {
+                    type: "Pres:DatastoreUpdate",
+                    content: {
+                        sendTimestamp: clock.now - 10,
+                        avgLatency: 20,
+                        data: {
+                            "system:presence": systemWorkspaceUpdate,
+                            "n:name:testNotificationWorkspace": notificationsWorkspaceUpdate,
+                        },
+                    },
+                    clientId: "client1",
+                }, false);
+                // Verify
+                assert.strictEqual(listener.calledOnce, true);
+                assert.strictEqual(listener.calledWith("name:testNotificationWorkspace", "Notifications"), true);
+            });
+            it("with unregistered workspace of unknown type emits 'workspaceActivated'", () => {
+                // Setup
+                const listener = spy();
+                presence.events.on("workspaceActivated", listener);
+                // Act
+                processSignal([], {
+                    type: "Pres:DatastoreUpdate",
+                    content: {
+                        sendTimestamp: clock.now - 10,
+                        avgLatency: 20,
+                        data: {
+                            "system:presence": systemWorkspaceUpdate,
+                            ["u:name:testUnknownWorkspace"]: {
+                                "latest": {
+                                    [attendeeId1]: {
+                                        "rev": 1,
+                                        "timestamp": 0,
+                                        "value": toOpaqueJson({ x: 1, y: 1, z: 1 }),
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    clientId: "client1",
+                }, false);
+                // Verify
+                assert.strictEqual(listener.calledOnce, true);
+                assert.strictEqual(listener.calledWith("name:testUnknownWorkspace", "Unknown"), true);
+            });
+            it("with registered workspace does NOT emit 'workspaceActivated'", () => {
+                // Setup
+                const listener = spy();
+                presence.events.on("workspaceActivated", listener);
+                presence.states.getWorkspace("name:testStateWorkspace", {});
+                presence.notifications.getWorkspace("name:testNotificationWorkspace", {});
+                // Act
+                processSignal([], {
+                    type: "Pres:DatastoreUpdate",
+                    content: {
+                        sendTimestamp: clock.now - 10,
+                        avgLatency: 20,
+                        data: {
+                            "system:presence": systemWorkspaceUpdate,
+                            "s:name:testStateWorkspace": statesWorkspaceUpdate,
+                            "n:name:testNotificationWorkspace": notificationsWorkspaceUpdate,
+                        },
+                    },
+                    clientId: "client1",
+                }, false);
+                // Verify
+                assert.strictEqual(listener.called, false);
+            });
+            it("with workspace that has an unrecognized internal address does NOT emit 'workspaceActivated'", () => {
+                // Setup
+                const listener = spy();
+                presence.events.on("workspaceActivated", listener);
+                // Act
+                processSignal([], {
+                    type: "Pres:DatastoreUpdate",
+                    content: {
+                        sendTimestamp: clock.now - 10,
+                        avgLatency: 20,
+                        data: {
+                            "system:presence": systemWorkspaceUpdate,
+                            // Unrecognized internal address
+                            ["sn:name:testStateWorkspace"]: statesWorkspaceUpdate,
+                        },
+                    },
+                    clientId: "client1",
+                }, false);
+                // Verify
+                assert.strictEqual(listener.called, false);
+            });
+            it("with workspace that has an invalid public address does NOT emit 'workspaceActivated'", () => {
+                // Setup
+                const listener = spy();
+                presence.events.on("workspaceActivated", listener);
+                // Act
+                processSignal([], {
+                    type: "Pres:DatastoreUpdate",
+                    content: {
+                        sendTimestamp: clock.now - 10,
+                        avgLatency: 20,
+                        data: {
+                            "system:presence": systemWorkspaceUpdate,
+                            // Invalid public address (must be `${string}:${string}`)
+                            ["s:testStateWorkspace"]: statesWorkspaceUpdate,
+                        },
+                    },
+                    clientId: "client1",
+                }, false);
+                // Verify
+                assert.strictEqual(listener.called, false);
+            });
+            it("with workspace that has already been seen does NOT emit 'workspaceActivated'", () => {
+                // Setup
+                const listener = spy();
+                presence.events.on("workspaceActivated", listener);
+                // Act
+                processSignal([], {
+                    type: "Pres:DatastoreUpdate",
+                    content: {
+                        sendTimestamp: clock.now - 20,
+                        avgLatency: 20,
+                        data: {
+                            "system:presence": systemWorkspaceUpdate,
+                            "s:name:testStateWorkspace": statesWorkspaceUpdate,
+                        },
+                    },
+                    clientId: "client1",
+                }, false);
+                processSignal([], {
+                    type: "Pres:DatastoreUpdate",
+                    content: {
+                        sendTimestamp: clock.now - 10,
+                        avgLatency: 20,
+                        data: {
+                            "system:presence": systemWorkspaceUpdate,
+                            "s:name:testStateWorkspace": statesWorkspaceUpdate,
+                        },
+                    },
+                    clientId: "client1",
+                }, false);
+                // Verify
+                assert.strictEqual(listener.callCount, 1);
+            });
+            it("with acknowledgementId sends targeted acknowledgment message back to requestor", () => {
+                // We expect to send a targeted acknowledgment back to the requestor
+                runtime.signalsExpected.push([
+                    {
+                        type: "Pres:Ack",
+                        content: { id: "ackID" },
+                        targetClientId: "client4",
+                    },
+                ]);
+                // Act - send generic datastore update with acknowledgement id specified
+                processSignal([], {
+                    type: "Pres:DatastoreUpdate",
+                    content: {
+                        sendTimestamp: clock.now - 10,
+                        avgLatency: 20,
+                        data: {
+                            "system:presence": systemWorkspaceUpdate,
+                            "s:name:testStateWorkspace": statesWorkspaceUpdate,
+                        },
+                        acknowledgementId: "ackID",
+                    },
+                    clientId: "client4",
+                }, false);
+                // Verify
+                assertFinalExpectations(runtime, logger);
+            });
+        });
+        describe("receiving unrecognized message", () => {
+            let presence;
+            let processSignal;
+            const systemWorkspaceUpdate = {
+                "clientToSessionId": {
+                    "client1": {
+                        "rev": 0,
+                        "timestamp": 0,
+                        "value": attendeeId1,
+                    },
+                },
+            };
+            const statesWorkspaceUpdate = {
+                "latest": {
+                    [attendeeId1]: {
+                        "rev": 1,
+                        "timestamp": 0,
+                        "value": toOpaqueJson({}),
+                    },
+                },
+            };
+            beforeEach(() => {
+                ({ presence, processSignal } = prepareConnectedPresence(runtime, localAttendeeId, initialLocalClientConnectionId, clock, logger));
+                // Pass a little time (to mimic reality)
+                clock.tick(10);
+            });
+            /**
+             * Use to pretend any general inbound message is an unverified Presence message
+             */
+            function markUnverifiedIncomingMessage(
+            // make sure message "was" at least serializable
+            message) {
+                return message;
+            }
+            function processUnrecognizedMessage({ optional }) {
+                // Mocked to look very much like a Presence message, but with an unrecognized type.
+                const unrecognizedMessage = {
+                    type: "Pres: Unrecognized Message",
+                    content: {
+                        sendTimestamp: clock.now - 10,
+                        avgLatency: 20,
+                        data: {
+                            "system:presence": systemWorkspaceUpdate,
+                            "s:name:testStateWorkspace": statesWorkspaceUpdate,
+                        },
+                    },
+                    clientId: "client1",
+                };
+                processSignal(optional ? ["?"] : [], markUnverifiedIncomingMessage(unrecognizedMessage), false);
+            }
+            it("that is NOT optional, throws", () => {
+                // Setup
+                const listener = spy();
+                presence.events.on("workspaceActivated", listener);
+                // Act & Verify
+                assert.throws(() => processUnrecognizedMessage({ optional: false }), validateAssertionError("0xcbc"));
+                // Verify
+                assert.strictEqual(listener.called, false);
+            });
+            it("that is optional, ignores message and does NOT throw", () => {
+                // Setup
+                const listener = spy();
+                presence.events.on("workspaceActivated", listener);
+                // Act & Verify
+                processUnrecognizedMessage({ optional: true });
+                // Verify
+                assert.strictEqual(listener.called, false);
+            });
+        });
+    });
+});
+//# sourceMappingURL=presenceDatastoreManager.spec.js.map