test(client-presence): old collateral connection and stale connection tests

packages/framework/presence/src/internalTypes.ts

@@ -4,8 +4,10 @@
  */
 
 import type { IContainerRuntime } from "@fluidframework/container-runtime-definitions/internal";
+import type { IEvent, IEventProvider } from "@fluidframework/core-interfaces";
 import type { IFluidDataStoreRuntime } from "@fluidframework/datastore-definitions/internal";
 
+import type { ClientConnectionId } from "./baseTypes.js";
 import type { InternalTypes } from "./exposedInternalTypes.js";
 import type { ClientSessionId, ISessionClient } from "./presence.js";
 
@@ -41,9 +43,19 @@ export const brandedObjectEntries = Object.entries as <K extends string, T>(
  */
 export type IEphemeralRuntime = Pick<
 	(IContainerRuntime & IRuntimeInternal) | IFluidDataStoreRuntime,
-	"clientId" | "connected" | "getAudience" | "getQuorum" | "off" | "on" | "submitSignal"
+	"clientId" | "connected" | "getAudience" | "getQuorum" | "submitSignal"
 > &
-	Partial<Pick<IFluidDataStoreRuntime, "logger">>;
+	Partial<Pick<IFluidDataStoreRuntime, "logger">> &
+	IEventProvider<EphemeralRuntimeEvents>;
+
+/**
+ * Events emitted by {@link IEphemeralRuntime}.
+ * @internal
+ */
+export interface EphemeralRuntimeEvents extends IEvent {
+	(event: "connected", listener: (clientId: ClientConnectionId) => void): void;
+	(event: "disconnected", listener: () => void): void;
+}
 
 /**
  * @internal

packages/framework/presence/src/test/mockEphemeralRuntime.ts

@@ -5,12 +5,13 @@
 
 import { strict as assert } from "node:assert";
 
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import type { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import type { IClient, ISequencedClient } from "@fluidframework/driver-definitions";
 import { MockAudience, MockQuorumClients } from "@fluidframework/test-runtime-utils/internal";
 
 import type { ClientConnectionId } from "../baseTypes.js";
-import type { IEphemeralRuntime } from "../internalTypes.js";
+import type { EphemeralRuntimeEvents, IEphemeralRuntime } from "../internalTypes.js";
 
 type ClientData = [string, IClient];
 
@@ -66,26 +67,19 @@ function makeMockAudience(clients: ClientData[]): MockAudience {
 /**
  * Mock ephemeral runtime for testing
  */
-export class MockEphemeralRuntime implements IEphemeralRuntime {
+export class MockEphemeralRuntime
+	extends TypedEventEmitter<EphemeralRuntimeEvents>
+	implements IEphemeralRuntime
+{
 	public logger?: ITelemetryBaseLogger;
 	public readonly quorum: MockQuorumClients;
 	public readonly audience: MockAudience;
 
-	public readonly listeners: {
-		connected: ((clientId: ClientConnectionId) => void)[];
-		disconnected: (() => void)[];
-	} = {
-		connected: [],
-		disconnected: [],
-	};
-	private isSupportedEvent(event: string): event is keyof typeof this.listeners {
-		return event in this.listeners;
-	}
-
 	public constructor(
 		logger?: ITelemetryBaseLogger,
 		public readonly signalsExpected: Parameters<IEphemeralRuntime["submitSignal"]>[] = [],
 	) {
+		super();
 		if (logger !== undefined) {
 			this.logger = logger;
 		}
@@ -98,29 +92,6 @@ export class MockEphemeralRuntime implements IEphemeralRuntime {
 		this.getQuorum = () => this.quorum;
 		this.audience = makeMockAudience(clientsData);
 		this.getAudience = () => this.audience;
-		this.on = (
-			event: string,
-			listener: (...args: any[]) => void,
-			// Events style eventing does not lend itself to union that
-			// IEphemeralRuntime is derived from, so we are using `any` here
-			// but meet the intent of the interface.
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		): any => {
-			if (!this.isSupportedEvent(event)) {
-				throw new Error(`Event ${event} is not supported`);
-			}
-			// Switch to allowing a single listener as commented when
-			// implementation uses a single "connected" listener.
-			// if (this.listeners[event]) {
-			// 	throw new Error(`Event ${event} already has a listener`);
-			// }
-			// this.listeners[event] = listener;
-			if (this.listeners[event].length > 1) {
-				throw new Error(`Event ${event} already has multiple listeners`);
-			}
-			this.listeners[event].push(listener);
-			return this;
-		};
 	}
 
 	public assertAllSignalsSubmitted(): void {
@@ -145,19 +116,22 @@ export class MockEphemeralRuntime implements IEphemeralRuntime {
 		this.audience.removeMember(clientId);
 	}
 
+	public connect(clientId: string): void {
+		this.clientId = clientId;
+		this.emit("connected", this.clientId);
+		this.connected = true;
+	}
+
+	public disconnect(): void {
+		this.emit("disconnected");
+		this.connected = false;
+	}
+
 	// #region IEphemeralRuntime
 
 	public clientId: string | undefined;
 	public connected: boolean = false;
 
-	public on: IEphemeralRuntime["on"];
-
-	public off: IEphemeralRuntime["off"] = (
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	): any => {
-		throw new Error("IEphemeralRuntime.off method not implemented.");
-	};
-
 	public getAudience: () => ReturnType<IEphemeralRuntime["getAudience"]>;
 
 	public getQuorum: () => ReturnType<IEphemeralRuntime["getQuorum"]>;

packages/framework/presence/src/test/presenceManager.spec.ts

@@ -249,7 +249,7 @@ describe("Presence", () => {
 						verifyAttendee(joinedAttendees[0], rejoinAttendeeConnectionId, attendeeSessionId);
 					});
 
-					it("as collateral and disconnected is NOT announced via `attendeeJoined`", () => {
+					it.skip("as collateral and disconnected is NOT announced via `attendeeJoined`", () => {
 						// Setup - remove connections from audience
 						const collateralAttendeeConnectionId = "client3";
 						const collateralAttendeeSignal = generateBasicClientJoin(clock.now - 10, {
@@ -282,6 +282,70 @@ describe("Presence", () => {
 
 						verifyAttendee(joinedAttendees[0], rejoinAttendeeConnectionId, attendeeSessionId);
 					});
+					it.skip("as collateral with old connection info and connected is NOT announced via `attendeeJoined`", () => {
+						// Setup - generate signals
+						const oldAttendeeConnectionId = "client9";
+						const newAttendeeConnectionId = "client10";
+
+						// Rejoin signal for attendee
+						const rejoinSignal = generateBasicClientJoin(clock.now - 10, {
+							averageLatency: 40,
+							clientSessionId: "collateral-id",
+							clientConnectionId: newAttendeeConnectionId,
+							updateProviders: [initialAttendeeConnectionId],
+							connectionOrder: 1,
+							priorClientToSessionId: {
+								[oldAttendeeConnectionId]: {
+									rev: 0,
+									timestamp: 0,
+									value: "collateral-id",
+								},
+							},
+						});
+
+						const responseSignal = generateBasicClientJoin(clock.now - 5, {
+							averageLatency: 20,
+							clientSessionId: 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: "collateral-id",
+								},
+							},
+						});
+
+						// 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",
+						);
+
+						// Act & Verify - simulate rejoin message from remote client
+						const rejoinAttendees = processJoinSignals([rejoinSignal]);
+						assert.strictEqual(
+							rejoinAttendees.length,
+							1,
+							"Expected exactly one attendee to be announced",
+						);
+						verifyAttendee(rejoinAttendees[0], newAttendeeConnectionId, "collateral-id");
+
+						// Act & Verify - simulate response message from remote client
+						const responseAttendees = processJoinSignals([responseSignal]);
+						assert.strictEqual(
+							responseAttendees.length,
+							0,
+							"Expected no attendees to be announced",
+						);
+						// Verify attendee information remains unchanged
+						verifyAttendee(rejoinAttendees[0], newAttendeeConnectionId, "collateral-id");
+					});
 				});
 
 				describe("that is already known", () => {
@@ -429,6 +493,80 @@ describe("Presence", () => {
 								clientToDisconnect,
 							);
 						});
+						it.skip("updates stale attendees status to 'Disconnected", () => {
+							// Setup
+							assert.ok(knownAttendee, "No attendee was set in beforeEach");
+							assert.strictEqual(
+								knownAttendee.getConnectionStatus(),
+								SessionClientStatus.Connected,
+								"Known attendee is not connected",
+							);
+
+							// Act - disconnect & reconnect local client
+							runtime.disconnect(); // Simulate local client disconnect
+							clock.tick(1000);
+							runtime.connect(rejoinAttendeeConnectionId); // Sinulate local client reconnect with new connection id
+
+							// Verify - stale attendee should still be connected after 15 seconds
+							clock.tick(15001);
+							assert.strictEqual(
+								knownAttendee.getConnectionStatus(),
+								SessionClientStatus.Connected,
+								"Stale attendee should still be connected",
+							);
+
+							// Verify - stale attendee should be disconnected after 30 seconds
+							clock.tick(15001);
+							assert.strictEqual(
+								knownAttendee.getConnectionStatus(),
+								SessionClientStatus.Disconnected,
+								"Stale attendee has wrong status",
+							);
+						});
+
+						it.skip("updates stale attendees status to 'Disconnected' afer multiple reconnects", () => {
+							// Setup
+							assert.ok(knownAttendee, "No attendee was set in beforeEach");
+							assert.strictEqual(
+								knownAttendee.getConnectionStatus(),
+								SessionClientStatus.Connected,
+								"Known attendee is not connected",
+							);
+
+							// Act - disconnect & reconnect local client
+							runtime.disconnect(); // Simulate local client disconnect
+							clock.tick(1000);
+							runtime.connect(rejoinAttendeeConnectionId); // Sinulate local client reconnect with new connection id
+
+							// Verify - stale attendee should still be connected after 15 seconds
+							clock.tick(15001);
+							assert.strictEqual(
+								knownAttendee.getConnectionStatus(),
+								SessionClientStatus.Connected,
+								"Stale attendee should still be connected",
+							);
+
+							// Act - disconnect & reconnect local client
+							runtime.disconnect(); // Simulate local client disconnect
+							clock.tick(1000);
+							runtime.connect("client7"); // Sinulate local client reconnect with new connection id
+
+							// Verify - stale attendee should still be connected after 15 seconds
+							clock.tick(15001);
+							assert.strictEqual(
+								knownAttendee.getConnectionStatus(),
+								SessionClientStatus.Connected,
+								"Stale attendee should still be connected",
+							);
+
+							// Verify - stale attendee
+							clock.tick(15001);
+							assert.equal(
+								knownAttendee.getConnectionStatus(),
+								SessionClientStatus.Disconnected,
+								"Stale attendee has wrong status",
+							);
+						});
 					});
 				});