@fluid-internal/presence-runtime 2.102.0 → 2.110.0

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

@@ -1,649 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { strict as assert } from "node:assert";
-import { AttendeeStatus } from "@fluid-internal/presence-definitions";
-import { EventAndErrorTrackingLogger } from "@fluidframework/test-utils/internal";
-import { useFakeTimers } from "sinon";
-import { createPresenceManager } from "@fluid-internal/presence-runtime/internal/test";
-import { assertFinalExpectations, initialLocalClientConnectionId, localAttendeeId, createSpecificAttendeeId, generateBasicClientJoin, MockEphemeralRuntime, prepareConnectedPresence, prepareDisconnectedPresence, } from "@fluid-internal/presence-runtime/internal/test-utils";
-const collateralSessionId = createSpecificAttendeeId("collateral-id");
-/**
- * Mock {@link ClientConnectionId} for the local client after first reconnection.
- */
-const rejoinedLocalClientConnectionId1 = "localClientRejoin1";
-/**
- * Mock {@link ClientConnectionId} for the local client after second reconnection.
- */
-const rejoinedLocalClientConnectionId2 = "localClientRejoin2";
-function verify(value, message) {
-    assert(value !== undefined, message ?? "Expected value to be defined");
-    return value;
-}
-describe("Presence/Runtime", () => {
-    describe("PresenceManager", () => {
-        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("can be created", () => {
-            // Act & Verify (does not throw)
-            createPresenceManager(runtime);
-        });
-        it("creation logs initialization event", () => {
-            // Setup
-            logger.registerExpectedEvent({ eventName: "Presence:PresenceInstantiated" });
-            // Act
-            createPresenceManager(runtime);
-            // Verify
-            assertFinalExpectations(runtime, logger);
-        });
-        it("throws when unknown attendee is requested via `getAttendee`", () => {
-            // Setup
-            const presence = createPresenceManager(runtime);
-            // Act & Verify
-            assert.throws(() => presence.attendees.getAttendee("unknown"), /Attendee not found/);
-        });
-        describe("self attendee", () => {
-            it("is announced via `attendeeConnected` upon connect while self is in audience", () => {
-                // Setup - create presence in disconnected state
-                const { presence, connect } = prepareDisconnectedPresence(runtime, localAttendeeId, initialLocalClientConnectionId, clock, logger);
-                const connectedAttendees = [];
-                presence.attendees.events.on("attendeeConnected", (attendee) => {
-                    connectedAttendees.push(attendee);
-                });
-                // Act - connect
-                connect();
-                // Verify - self attendee was announced
-                const selfAttendee = presence.attendees.getMyself();
-                assert.strictEqual(connectedAttendees.length, 1, "Expected exactly one attendee to be announced");
-                assert.strictEqual(connectedAttendees[0], selfAttendee, "Expected self attendee to be announced");
-            });
-            it('has status "Disconnected" when presence initializes while container is disconnected', () => {
-                // Setup - create presence while container is disconnected
-                const { presence } = prepareDisconnectedPresence(runtime, localAttendeeId, initialLocalClientConnectionId, clock, logger);
-                // Verify - self attendee has "Disconnected" status
-                const selfAttendee = presence.attendees.getMyself();
-                assert.strictEqual(selfAttendee.getConnectionStatus(), AttendeeStatus.Disconnected, "Self attendee should have status 'Disconnected' when presence initializes while container is disconnected");
-            });
-            it('has status "Disconnected" when runtime is connected but self is not yet in Audience', () => {
-                // Setup - set runtime to connected state but remove self from audience
-                runtime.clientId = initialLocalClientConnectionId;
-                runtime.joined = true;
-                runtime.removeMember(initialLocalClientConnectionId);
-                // Create presence - it will see runtime as connected but self not in audience
-                logger.registerExpectedEvent({ eventName: "Presence:PresenceInstantiated" });
-                const presence = createPresenceManager(runtime, localAttendeeId);
-                // Verify - self attendee should have "Disconnected" status since
-                // we haven't received the ClientJoin signal yet
-                const selfAttendee = presence.attendees.getMyself();
-                assert.strictEqual(selfAttendee.getConnectionStatus(), AttendeeStatus.Disconnected, "Self attendee should have status 'Disconnected' when runtime is connected but self is not yet in Audience");
-                assertFinalExpectations(runtime, logger);
-            });
-            it("is announced via `attendeeConnected` when added to Audience while runtime is connected", () => {
-                // Setup - set runtime to connected state but remove self from audience
-                runtime.clientId = initialLocalClientConnectionId;
-                runtime.joined = true;
-                runtime.removeMember(initialLocalClientConnectionId);
-                // Create presence - it will see runtime as connected but self not in audience
-                logger.registerExpectedEvent({ eventName: "Presence:PresenceInstantiated" });
-                const presence = createPresenceManager(runtime, localAttendeeId);
-                // Verify initial state - self is Disconnected
-                const selfAttendee = presence.attendees.getMyself();
-                assert.strictEqual(selfAttendee.getConnectionStatus(), AttendeeStatus.Disconnected, "Self attendee should initially have status 'Disconnected'");
-                // Listen for attendeeConnected
-                const connectedAttendees = [];
-                presence.attendees.events.on("attendeeConnected", (attendee) => {
-                    connectedAttendees.push(attendee);
-                });
-                // Expect join signal when self is added to audience while connected
-                const expectedJoin = generateBasicClientJoin(clock.now, {
-                    attendeeId: localAttendeeId,
-                    clientConnectionId: initialLocalClientConnectionId,
-                    updateProviders: ["client0", "client1", "client3"],
-                });
-                delete expectedJoin.clientId;
-                runtime.signalsExpected.push([expectedJoin]);
-                // Act - self added to audience
-                runtime.audience.addMember(initialLocalClientConnectionId, {
-                    mode: "write",
-                    details: { capabilities: { interactive: true } },
-                    permission: [],
-                    user: { id: "test-user" },
-                    scopes: [],
-                });
-                // Verify - attendeeConnected was raised for self with Connected status
-                assert.strictEqual(connectedAttendees.length, 1, "Expected exactly one attendee to be announced");
-                assert.strictEqual(connectedAttendees[0], selfAttendee, "Expected self attendee to be announced");
-                assert.strictEqual(selfAttendee.getConnectionStatus(), AttendeeStatus.Connected, "Self attendee should have status 'Connected' after being added to Audience");
-                assertFinalExpectations(runtime, logger);
-            });
-            it('has status "Connected" when announced via `attendeeConnected`', () => {
-                // Setup - create presence in disconnected state
-                const { presence, connect } = prepareDisconnectedPresence(runtime, localAttendeeId, initialLocalClientConnectionId, clock, logger);
-                let attendeeConnectedRaised = false;
-                presence.attendees.events.on("attendeeConnected", (attendee) => {
-                    if (attendee === presence.attendees.getMyself()) {
-                        attendeeConnectedRaised = true;
-                        assert.strictEqual(attendee.getConnectionStatus(), AttendeeStatus.Connected, "Self attendee should have status 'Connected' when announced");
-                    }
-                });
-                // Act - connect
-                connect();
-                // Verify - attendeeConnected was raised
-                assert(attendeeConnectedRaised, "attendeeConnected event should be raised for self attendee");
-            });
-            it("is announced via `attendeeDisconnected` when local client disconnects", () => {
-                // Setup - create presence in disconnected state and connect
-                const { presence, connect } = prepareDisconnectedPresence(runtime, localAttendeeId, initialLocalClientConnectionId, clock, logger);
-                connect();
-                const disconnectedAttendees = [];
-                presence.attendees.events.on("attendeeDisconnected", (attendee) => {
-                    disconnectedAttendees.push(attendee);
-                });
-                // Act - disconnect
-                runtime.disconnect();
-                // Verify - self attendee was announced as disconnected
-                const selfAttendee = presence.attendees.getMyself();
-                assert.strictEqual(disconnectedAttendees.length, 1, "Expected exactly one attendee to be announced as disconnected");
-                assert.strictEqual(disconnectedAttendees[0], selfAttendee, "Expected self attendee to be announced as disconnected");
-                assert.strictEqual(selfAttendee.getConnectionStatus(), AttendeeStatus.Disconnected, "Self attendee should have status 'Disconnected' after disconnect");
-            });
-            it("is announced via `attendeeConnected` when local client reconnects", () => {
-                // Setup - create presence in disconnected state, connect and then disconnect
-                const { presence, connect } = prepareDisconnectedPresence(runtime, localAttendeeId, initialLocalClientConnectionId, clock, logger);
-                // Initial connection
-                connect();
-                // Disconnect
-                runtime.disconnect();
-                // Ignore submitted signals for reconnection
-                runtime.submitSignal = () => { };
-                const connectedAttendees = [];
-                presence.attendees.events.on("attendeeConnected", (attendee) => {
-                    connectedAttendees.push(attendee);
-                });
-                // Act - reconnect with new connection id
-                runtime.connect(rejoinedLocalClientConnectionId1, initialLocalClientConnectionId);
-                // Verify - self attendee was announced
-                const selfAttendee = presence.attendees.getMyself();
-                assert.strictEqual(connectedAttendees.length, 1, "Expected exactly one attendee to be announced on reconnect");
-                assert.strictEqual(connectedAttendees[0], selfAttendee, "Expected self attendee to be announced on reconnect");
-                assert.strictEqual(selfAttendee.getConnectionStatus(), AttendeeStatus.Connected, "Self attendee should have status 'Connected' after reconnect");
-            });
-        });
-        describe("when connected", () => {
-            let presence;
-            let processSignal;
-            const afterCleanUp = [];
-            beforeEach(() => {
-                ({ presence, processSignal } = prepareConnectedPresence(runtime, localAttendeeId, initialLocalClientConnectionId, clock, logger));
-            });
-            afterEach(() => {
-                for (const cleanUp of afterCleanUp) {
-                    cleanUp();
-                }
-                afterCleanUp.length = 0;
-            });
-            describe("attendee", () => {
-                const attendeeSessionId = "attendeeId-4";
-                const initialAttendeeConnectionId = "client4";
-                // Note: this connection id exists in the mock runtime audience since
-                // initialization, but should go unnoticed by the presence manager
-                // until there is a join signal related to it.
-                const rejoinAttendeeConnectionId = "client7";
-                let initialAttendeeSignal;
-                let rejoinAttendeeSignal;
-                // Processes join signals and returns the attendees that were announced via `attendeeConnected`
-                function processJoinSignals(signals) {
-                    const joinedAttendees = [];
-                    const cleanUpListener = presence.attendees.events.on("attendeeConnected", (attendee) => {
-                        joinedAttendees.push(attendee);
-                    });
-                    for (const signal of signals) {
-                        processSignal([], signal, false);
-                    }
-                    cleanUpListener();
-                    return joinedAttendees;
-                }
-                function verifyAttendee(actualAttendee, expectedConnectionId, expectedSessionId, expectedConnectionStatus = AttendeeStatus.Connected) {
-                    assert.equal(actualAttendee.attendeeId, expectedSessionId, "Attendee has wrong session id");
-                    assert.equal(actualAttendee.getConnectionId(), expectedConnectionId, "Attendee has wrong client connection id");
-                    assert.equal(actualAttendee.getConnectionStatus(), expectedConnectionStatus, `Attendee connection status is not ${expectedConnectionStatus}`);
-                }
-                beforeEach(() => {
-                    // Ignore submitted signals
-                    runtime.submitSignal = () => { };
-                    initialAttendeeSignal = generateBasicClientJoin(clock.now - 50, {
-                        averageLatency: 50,
-                        attendeeId: attendeeSessionId,
-                        clientConnectionId: initialAttendeeConnectionId,
-                        updateProviders: [initialLocalClientConnectionId],
-                    });
-                    rejoinAttendeeSignal = generateBasicClientJoin(clock.now - 20, {
-                        averageLatency: 20,
-                        attendeeId: attendeeSessionId, // Same session id
-                        clientConnectionId: rejoinAttendeeConnectionId, // Different connection id
-                        connectionOrder: 1,
-                        updateProviders: [initialLocalClientConnectionId],
-                        priorClientToSessionId: initialAttendeeSignal.content.data["system:presence"].clientToSessionId,
-                    });
-                });
-                it("is not announced via `attendeeDisconnected` when unknown connection is removed", () => {
-                    // Setup
-                    presence.attendees.events.on("attendeeDisconnected", () => {
-                        assert.fail("`attendeeDisconnected` should not be emitted for unknown connection.");
-                    });
-                    // Act & Verify - remove connection unknown to presence
-                    runtime.removeMember("client5");
-                });
-                describe("that is joining", () => {
-                    it('first time is announced via `attendeeConnected` with status "Connected"', () => {
-                        // Act - simulate join message from client
-                        const joinedAttendees = processJoinSignals([initialAttendeeSignal]);
-                        // Verify
-                        assert.strictEqual(joinedAttendees.length, 1, "Expected exactly one attendee to be announced");
-                        verifyAttendee(joinedAttendees[0], initialAttendeeConnectionId, attendeeSessionId);
-                    });
-                    it('second time is announced once via `attendeeConnected` with status "Connected" when prior is unknown', () => {
-                        // Setup
-                        const priorClientData = verify(runtime.getAudience().getMember(initialAttendeeConnectionId));
-                        runtime.removeMember(initialAttendeeConnectionId);
-                        runtime.audience.addMember(rejoinAttendeeConnectionId, priorClientData);
-                        // Act - simulate join message from client
-                        const joinedAttendees = processJoinSignals([rejoinAttendeeSignal]);
-                        // Verify
-                        assert.strictEqual(joinedAttendees.length, 1, "Expected exactly one attendee to be announced");
-                        verifyAttendee(joinedAttendees[0], rejoinAttendeeConnectionId, attendeeSessionId);
-                    });
-                    it('second time is announced once via `attendeeConnected` with status "Connected" when prior is still connected', () => {
-                        const initialClientData = verify(runtime.getAudience().getMember(initialAttendeeConnectionId));
-                        runtime.audience.addMember(rejoinAttendeeConnectionId, initialClientData);
-                        // Act - simulate join message from client
-                        const joinedAttendees = processJoinSignals([rejoinAttendeeSignal]);
-                        // Verify
-                        assert.strictEqual(joinedAttendees.length, 1, "Expected exactly one attendee to be announced");
-                        verifyAttendee(joinedAttendees[0], rejoinAttendeeConnectionId, attendeeSessionId);
-                    });
-                    it('first time is announced via `attendeeConnected` with status "Connected" even if unknown to audience', () => {
-                        // Setup - remove connection from audience
-                        runtime.removeMember(initialAttendeeConnectionId);
-                        // Act - simulate join message from client
-                        const joinedAttendees = processJoinSignals([initialAttendeeSignal]);
-                        // Verify
-                        assert.strictEqual(joinedAttendees.length, 1, "Expected exactly one attendee to be announced");
-                        verifyAttendee(joinedAttendees[0], initialAttendeeConnectionId, attendeeSessionId);
-                    });
-                    it('second time is announced once via `attendeeConnected` with status "Connected" even if most recent unknown to audience', () => {
-                        // Setup - remove connection from audience
-                        runtime.removeMember(rejoinAttendeeConnectionId);
-                        // Act - simulate join message from client
-                        const joinedAttendees = processJoinSignals([rejoinAttendeeSignal]);
-                        assert.strictEqual(joinedAttendees.length, 1, "Expected exactly one attendee to be announced");
-                        verifyAttendee(joinedAttendees[0], rejoinAttendeeConnectionId, attendeeSessionId);
-                    });
-                    it("as collateral and disconnected is NOT announced via `attendeeConnected`", () => {
-                        // Setup - remove connections from audience
-                        const collateralAttendeeConnectionId = "client3";
-                        const collateralAttendeeSignal = generateBasicClientJoin(clock.now - 10, {
-                            averageLatency: 40,
-                            attendeeId: attendeeSessionId,
-                            clientConnectionId: rejoinAttendeeConnectionId,
-                            connectionOrder: 1,
-                            updateProviders: [initialLocalClientConnectionId],
-                            priorClientToSessionId: {
-                                ...initialAttendeeSignal.content.data["system:presence"].clientToSessionId,
-                                [collateralAttendeeConnectionId]: {
-                                    rev: 0,
-                                    timestamp: 0,
-                                    value: collateralSessionId,
-                                },
-                            },
-                        });
-                        runtime.removeMember(initialAttendeeConnectionId);
-                        runtime.removeMember(collateralAttendeeConnectionId);
-                        // Act - simulate join message from client
-                        const joinedAttendees = processJoinSignals([collateralAttendeeSignal]);
-                        // Verify - only the rejoining attendee is announced
-                        assert.strictEqual(joinedAttendees.length, 1, "Expected exactly one attendee to be announced");
-                        verifyAttendee(joinedAttendees[0], rejoinAttendeeConnectionId, attendeeSessionId);
-                    });
-                    it("as collateral with old connection info and connected is NOT announced via `attendeeConnected`", () => {
-                        // Setup - generate signals
-                        // Both connection Id's unknown to audience
-                        const oldAttendeeConnectionId = "client9";
-                        const newAttendeeConnectionId = "client10";
-                        // Rejoin signal for the collateral attendee unknown to audience
-                        const rejoinSignal = generateBasicClientJoin(clock.now - 10, {
-                            averageLatency: 40,
-                            attendeeId: collateralSessionId,
-                            clientConnectionId: newAttendeeConnectionId,
-                            updateProviders: [initialAttendeeConnectionId],
-                            connectionOrder: 1,
-                            priorClientToSessionId: {
-                                [oldAttendeeConnectionId]: {
-                                    rev: 0,
-                                    timestamp: 0,
-                                    value: collateralSessionId,
-                                },
-                            },
-                        });
-                        // Response signal sent by the initial attendee responding to the collateral attendees rejoin signal
-                        const responseSignal = generateBasicClientJoin(clock.now - 5, {
-                            averageLatency: 20,
-                            attendeeId: attendeeSessionId,
-                            clientConnectionId: initialAttendeeConnectionId,
-                            priorClientToSessionId: {
-                                ...initialAttendeeSignal.content.data["system:presence"].clientToSessionId,
-                                // Old connection id of rejoining attendee
-                                // This should be ignored by local client
-                                [oldAttendeeConnectionId]: {
-                                    rev: 0,
-                                    timestamp: 0,
-                                    value: collateralSessionId,
-                                },
-                            },
-                        });
-                        // Process initial join signal so initial attendee is known
-                        const joinedAttendees = processJoinSignals([initialAttendeeSignal]);
-                        assert.strictEqual(joinedAttendees.length, 1, "Expected exactly one attendee to be announced");
-                        // Simulate rejoin message from remote client
-                        const rejoinAttendees = processJoinSignals([rejoinSignal]);
-                        // Confirm that rejoining attendee is announced so we can verify it remains the same after response
-                        assert.strictEqual(rejoinAttendees.length, 1, "Expected exactly one attendee to be announced");
-                        // Act - simulate response message from remote client
-                        const responseAttendees = processJoinSignals([responseSignal]);
-                        // Verify - No collateral attendee should be announced by response signal and rejoined attendee information should remain unchanged
-                        assert.strictEqual(responseAttendees.length, 0, "Expected no attendees to be announced");
-                        // Check attendee information remains unchanged
-                        verifyAttendee(rejoinAttendees[0], newAttendeeConnectionId, collateralSessionId);
-                    });
-                });
-                describe("that is already known", () => {
-                    let knownAttendee;
-                    beforeEach(() => {
-                        // Setup known attendee
-                        const joinedAttendees = processJoinSignals([initialAttendeeSignal]);
-                        assert(joinedAttendees.length === 1, "Expected exactly one attendee to be announced");
-                        knownAttendee = joinedAttendees[0];
-                    });
-                    it('is NOT announced when "rejoined" with same connection (duplicate signal)', () => {
-                        afterCleanUp.push(presence.attendees.events.on("attendeeConnected", (attendee) => {
-                            assert.fail("Attendee should not be announced when rejoining with same connection");
-                        }));
-                        clock.tick(10);
-                        // Act & Verify - simulate duplicate join message from client
-                        processJoinSignals([initialAttendeeSignal]);
-                    });
-                    // To retain symmetry across Joined and Disconnected events, do not announce
-                    // attendeeConnected when the attendee is already connected and we only see
-                    // a connection id update. This can happen when audience removal is late.
-                    it('is not announced via `attendeeConnected` when already "Connected"', () => {
-                        // Setup
-                        afterCleanUp.push(presence.attendees.events.on("attendeeConnected", () => {
-                            assert.fail("No attendee should be announced in join processing");
-                        }));
-                        // Act & Verify - simulate rejoin message from client
-                        processJoinSignals([rejoinAttendeeSignal]);
-                    });
-                    for (const [status, setup] of [
-                        [AttendeeStatus.Connected, () => { }],
-                        [
-                            AttendeeStatus.Disconnected,
-                            () => runtime.removeMember(initialAttendeeConnectionId),
-                        ],
-                    ]) {
-                        for (const [desc, id] of [
-                            ["connection id", initialAttendeeConnectionId],
-                            ["session id", attendeeSessionId],
-                        ]) {
-                            it(`with status "${status}" is available from \`getAttendee\` by ${desc}`, () => {
-                                // Setup
-                                setup();
-                                // Act
-                                const attendee = presence.attendees.getAttendee(id);
-                                // Verify
-                                assert.equal(attendee, knownAttendee, "`getAttendee` returned wrong attendee");
-                                assert.equal(attendee.getConnectionStatus(), status, "`getAttendee` returned attendee with wrong status");
-                            });
-                        }
-                        it(`with status "${status}" is available from \`getAttendees\``, () => {
-                            // Setup
-                            assert(knownAttendee !== undefined, "No attendee was set in beforeEach");
-                            setup();
-                            // Act
-                            const attendees = presence.attendees.getAttendees();
-                            assert(attendees.has(knownAttendee), "`getAttendees` set does not contain attendee");
-                            assert.equal(knownAttendee.getConnectionStatus(), status, "`getAttendees` set contains attendee with wrong status");
-                        });
-                    }
-                    // When local client disconnects, we lose the connectivity status updates for remote attendees in the session.
-                    // Upon reconnect, we mark all remote attendees connections as "stale".
-                    // Remote attendees with stale connections are given 30 seconds after local reconnection to prove they are connected
-                    // (e.g. being in audience, sending an update, or (re)joining the session) before their connection status set to "Disconnected".
-                    // If an attendee with a stale connection becomes active, their "stale" status is removed.
-                    describe("and then local client disconnects", () => {
-                        let remoteDisconnectedAttendees;
-                        beforeEach(() => {
-                            // Setup
-                            assert(knownAttendee !== undefined, "No attendee was set in beforeEach");
-                            remoteDisconnectedAttendees = [];
-                            afterCleanUp.push(presence.attendees.events.on("attendeeDisconnected", (attendee) => {
-                                if (attendee !== presence.attendees.getMyself()) {
-                                    remoteDisconnectedAttendees.push(attendee);
-                                }
-                            }));
-                        });
-                        it("updates status of attendee with stale connection after 30s delay upon local reconnection", () => {
-                            assert(knownAttendee !== undefined, "No attendee was set in beforeEach");
-                            // Act - disconnect & reconnect local client
-                            runtime.disconnect(); // Simulate local client disconnect
-                            clock.tick(1000);
-                            // Simulate remote client disconnect (while local is disconnected)
-                            runtime.audience.removeMember(knownAttendee.getConnectionId());
-                            runtime.connect(rejoinedLocalClientConnectionId1, initialLocalClientConnectionId); // Simulate local client reconnect with new connection id
-                            // Verify - attendee with stale connection should still be 'Connected' after 15 seconds
-                            clock.tick(15_001);
-                            assert.strictEqual(knownAttendee.getConnectionStatus(), AttendeeStatus.Connected, "Attendee with stale connection should still be 'Connected' after 15s");
-                            // Verify - attendee with stale connection should be 'Disconnected' after 30 seconds and announced via `attendeeDisconnected`
-                            clock.tick(15_001);
-                            assert.strictEqual(knownAttendee.getConnectionStatus(), AttendeeStatus.Disconnected, "Attendee with stale connection should be 'Disconnected' 30s after reconnection");
-                            assert.strictEqual(remoteDisconnectedAttendees.length, 1, "Exactly one attendee should be announced as disconnected");
-                        });
-                        it("does not update status of attendee with stale connection if local client does not reconnect", () => {
-                            assert(knownAttendee !== undefined, "No attendee was set in beforeEach");
-                            // Act - disconnect local client and advance timer
-                            runtime.disconnect();
-                            clock.tick(600_000);
-                            // Verify - attendee with stale connection should still be 'Connected' if local client never reconnects
-                            assert.strictEqual(knownAttendee.getConnectionStatus(), AttendeeStatus.Connected, "Attendee with stale connection should still be 'Connected' after 30s");
-                        });
-                        it("does not update status of attendee with stale connection if local client reconnection lasts less than 30s", () => {
-                            assert(knownAttendee !== undefined, "No attendee was set in beforeEach");
-                            // Act - disconnect, reconnect for 15 second, disconnect local client again, then advance timer
-                            runtime.disconnect(); // First disconnect
-                            clock.tick(1000);
-                            runtime.connect(rejoinedLocalClientConnectionId1, initialLocalClientConnectionId); // Reconnect
-                            clock.tick(15_000); // Advance 15 seconds
-                            runtime.disconnect(); // Disconnect again
-                            clock.tick(600_000); // Advance 10 minutes
-                            // Verify - attendee with stale connection should still be 'Connected' if local client never reconnects for at least 30s
-                            assert.strictEqual(knownAttendee.getConnectionStatus(), AttendeeStatus.Connected, "Attendee with stale connection should still be 'Connected' after 30s");
-                        });
-                        it("does not update status of attendee with stale connection if attendee rejoins", () => {
-                            assert(knownAttendee !== undefined, "No attendee was set in beforeEach");
-                            // Setup - fail if non-self attendee joined is announced
-                            afterCleanUp.push(presence.attendees.events.on("attendeeConnected", (attendee) => {
-                                // Self attendee will be announced on reconnect, which is expected
-                                assert(attendee === presence.attendees.getMyself(), "No `attendeeConnected` should be announced for rejoining attendee that's already 'Connected'");
-                            }));
-                            // Act - disconnect, reconnect, process rejoin signal from known attendee after 15s, then advance timer
-                            runtime.disconnect();
-                            clock.tick(1000);
-                            runtime.connect(rejoinedLocalClientConnectionId1, initialLocalClientConnectionId);
-                            clock.tick(15_000);
-                            processJoinSignals([rejoinAttendeeSignal]);
-                            clock.tick(600_000);
-                            // Verify - rejoining attendee should still be 'Connected' with no `attendeeConnected` announced
-                            assert.strictEqual(knownAttendee.getConnectionStatus(), AttendeeStatus.Connected, "Active attendee should still be 'Connected' 30s after reconnection");
-                        });
-                        it("does not update status of attendee with stale connection if attendee sends datastore update", () => {
-                            assert(knownAttendee !== undefined, "No attendee was set in beforeEach");
-                            // Setup - fail if non-self attendee joined is announced
-                            afterCleanUp.push(presence.attendees.events.on("attendeeConnected", (attendee) => {
-                                // Self attendee will be announced on reconnect, which is expected
-                                assert(attendee === presence.attendees.getMyself(), "No `attendeeConnected` should be announced for active attendee that's already 'Connected'");
-                            }));
-                            // Act - disconnect, reconnect, process datatstore update signal from known attendee before 30s delay, then advance timer
-                            runtime.disconnect();
-                            clock.tick(1000);
-                            runtime.connect(rejoinedLocalClientConnectionId1, initialLocalClientConnectionId);
-                            clock.tick(15_000);
-                            processSignal([], {
-                                type: "Pres:DatastoreUpdate",
-                                content: {
-                                    sendTimestamp: clock.now - 10,
-                                    avgLatency: 20,
-                                    data: {
-                                        "system:presence": {
-                                            clientToSessionId: initialAttendeeSignal.content.data["system:presence"]
-                                                .clientToSessionId,
-                                        },
-                                    },
-                                },
-                                clientId: initialAttendeeConnectionId,
-                            }, false);
-                            clock.tick(600_000);
-                            // Verify - active attendee should still be 'Connected'
-                            assert.strictEqual(knownAttendee.getConnectionStatus(), AttendeeStatus.Connected, "Active attendee should still be 'Connected' 30s after reconnection");
-                        });
-                        it("announces `attendeeDisconnected` once when remote client disconnects after local client reconnects", () => {
-                            assert(knownAttendee !== undefined, "No attendee was set in beforeEach");
-                            // Setup - initial attendee joins before local client disconnects
-                            processJoinSignals([initialAttendeeSignal]);
-                            // Act - disconnect, reconnect, remove remote client connection, then advance timer
-                            runtime.disconnect();
-                            clock.tick(1000);
-                            runtime.connect(rejoinedLocalClientConnectionId1, initialLocalClientConnectionId);
-                            clock.tick(15_001);
-                            runtime.audience.removeMember(initialAttendeeConnectionId); // Remove remote client connection before 30s timeout
-                            // Confirm that `attendeeDisconnected` is announced for when active attendee disconnects
-                            assert.strictEqual(remoteDisconnectedAttendees.length, 1, "Exactly one attendee should be announced as disconnected");
-                            clock.tick(600_000);
-                            // Verify - active attendee status should be 'Disconnected' and no other `attendeeDisconnected` should be announced.
-                            assert.strictEqual(knownAttendee.getConnectionStatus(), AttendeeStatus.Disconnected, "Attendee should be 'Disconnected'");
-                            assert.strictEqual(remoteDisconnectedAttendees.length, 1, "Exactly one attendee should be announced as disconnected");
-                        });
-                        it("updates status of attendee with stale connection only 30s after most recent local reconnection", () => {
-                            // Setup
-                            assert(knownAttendee !== undefined, "No attendee was set in beforeEach");
-                            assert.strictEqual(knownAttendee.getConnectionStatus(), AttendeeStatus.Connected, "Known attendee is not connected");
-                            // Act - disconnect & reconnect local client multiple times with 15s delay
-                            runtime.disconnect();
-                            runtime.audience.removeMember(knownAttendee.getConnectionId()); // Simulate remote client disconnect (while local is disconnected)
-                            clock.tick(1000);
-                            runtime.connect(rejoinedLocalClientConnectionId1, initialLocalClientConnectionId);
-                            clock.tick(15_001);
-                            runtime.disconnect();
-                            clock.tick(1000);
-                            runtime.connect(rejoinedLocalClientConnectionId2, rejoinedLocalClientConnectionId1);
-                            // Verify - attendee with stale connection should still be connected after 15 seconds
-                            clock.tick(15_001);
-                            assert.strictEqual(knownAttendee.getConnectionStatus(), AttendeeStatus.Connected, "Attendee with stale connection should still be connected");
-                            // Verify - attendee with stale connection should be disconnected after 30 seconds
-                            clock.tick(15_001);
-                            assert.equal(knownAttendee.getConnectionStatus(), AttendeeStatus.Disconnected, "Attendee with stale connection has wrong status");
-                            assert.strictEqual(remoteDisconnectedAttendees.length, 1, "Exactly one attendee should be announced as disconnected");
-                        });
-                    });
-                    describe("and has their connection removed", () => {
-                        it("is announced via `attendeeDisconnected`", () => {
-                            // Setup
-                            assert(knownAttendee !== undefined, "No attendee was set in beforeEach");
-                            let disconnectedAttendee;
-                            afterCleanUp.push(presence.attendees.events.on("attendeeDisconnected", (attendee) => {
-                                assert(disconnectedAttendee === undefined, "Only one attendee should be disconnected");
-                                disconnectedAttendee = attendee;
-                            }));
-                            // Act - remove client connection id
-                            runtime.removeMember(initialAttendeeConnectionId);
-                            // Verify
-                            assert(disconnectedAttendee !== undefined, "No attendee was disconnected during `removeMember`");
-                            verifyAttendee(disconnectedAttendee, initialAttendeeConnectionId, attendeeSessionId, AttendeeStatus.Disconnected);
-                        });
-                        it('is not announced via `attendeeDisconnected` when already "Disconnected"', () => {
-                            // Setup
-                            const clientToDisconnect = runtime.audience.getMember(initialAttendeeConnectionId);
-                            assert(clientToDisconnect !== undefined, "No client to disconnect");
-                            // Remove client connection id
-                            runtime.removeMember(initialAttendeeConnectionId);
-                            afterCleanUp.push(presence.attendees.events.on("attendeeDisconnected", (attendee) => {
-                                assert.fail("`attendeeDisconnected` should not be emitted for already disconnected attendee");
-                            }));
-                            // Act & Verify - fake event to remove client connection id again
-                            runtime.audience.emit("removeMember", initialAttendeeConnectionId, clientToDisconnect);
-                        });
-                    });
-                });
-                describe("that is rejoining", () => {
-                    let priorClientData;
-                    let priorAttendee;
-                    beforeEach(() => {
-                        priorClientData = verify(runtime.getAudience().getMember(initialAttendeeConnectionId));
-                        // Setup prior attendee
-                        const joinedAttendees = processJoinSignals([initialAttendeeSignal]);
-                        assert(joinedAttendees.length === 1 && joinedAttendees[0] !== undefined, "Expected exactly one attendee to be announced");
-                        priorAttendee = joinedAttendees[0];
-                        // Disconnect the attendee
-                        runtime.removeMember(initialAttendeeConnectionId);
-                    });
-                    it("is NOT announced when rejoined with same connection (duplicate signal)", () => {
-                        // Setup
-                        afterCleanUp.push(presence.attendees.events.on("attendeeConnected", (attendee) => {
-                            assert.fail("Attendee should not be announced when rejoining with same connection");
-                        }));
-                        clock.tick(10);
-                        // Act & Verify - simulate duplicate join message from client
-                        processJoinSignals([initialAttendeeSignal]);
-                    });
-                    it("is announced when rejoined with different connection and current information is updated", () => {
-                        // Setup
-                        assert(priorAttendee !== undefined, "No attendee was set in beforeEach");
-                        clock.tick(20);
-                        // Act - add to audience and simulate new join message from same client (without disconnect)
-                        runtime.audience.addMember(rejoinAttendeeConnectionId, priorClientData);
-                        processJoinSignals([rejoinAttendeeSignal]);
-                        // Verify - session id is unchanged and connection id is updated
-                        verifyAttendee(priorAttendee, rejoinAttendeeConnectionId, attendeeSessionId);
-                        // Attendee is available via new connection id
-                        const attendeeViaUpdatedId = presence.attendees.getAttendee(rejoinAttendeeConnectionId);
-                        assert.equal(attendeeViaUpdatedId, priorAttendee, "getAttendee returned wrong attendee for updated connection id");
-                        // Attendee is available via old connection id
-                        const attendeeViaOriginalId = presence.attendees.getAttendee(initialAttendeeConnectionId);
-                        assert.equal(attendeeViaOriginalId, priorAttendee, "getAttendee returned wrong attendee for original connection id");
-                    });
-                });
-            });
-        });
-    });
-});
-//# sourceMappingURL=presenceManager.spec.js.map