@fluidframework/azure-end-to-end-tests 2.70.0-361788 → 2.71.0

package/src/test/multiprocess/presenceTest.spec.ts

@@ -25,6 +25,14 @@ import {
 	waitForLatestValueUpdates,
 } from "./orchestratorUtils.js";
 
+/**
+ * When true, slower (long running time) tests will be run.
+ * Otherwise, those test will not appear. Console output is used to show that
+ * they exist. (They could be skipped, though skipped test are often an
+ * indication of a problem.)
+ */
+const shouldRunScaleTests = process.env.FLUID_TEST_SCALE !== undefined;
+
 const useAzure = process.env.FLUID_CLIENT === "azure";
 
 /**
@@ -35,7 +43,7 @@ const debuggerAttached = inspector.url() !== undefined;
 /**
  * Set this to a high number when debugging to avoid timeouts from debugging time.
  */
-const timeoutMultiplier = debuggerAttached ? 1000 : useAzure ? 3 : 1;
+const timeoutMultiplier = debuggerAttached ? 1000 : useAzure ? 5 : 1;
 
 /**
  * Sets the timeout for the given test context.
@@ -98,215 +106,214 @@ describe(`Presence with AzureClient`, () => {
 		afterCleanUp.length = 0;
 	});
 
-	// Note that on slower systems 50+ clients may take too long to join.
-	const numClientsForAttendeeTests = [5, 20, 50, 100];
-	// TODO: AB#45620: "Presence: perf: update Join pattern for scale" may help, then remove .slice.
-	for (const numClients of numClientsForAttendeeTests.slice(0, 2)) {
-		assert(numClients > 1, "Must have at least two clients");
-		/**
-		 * Timeout for child processes to connect to container ({@link ConnectedEvent})
-		 */
-		const childConnectTimeoutMs = 1000 * numClients * timeoutMultiplier;
-		/**
-		 * Timeout for presence attendees to join per first child perspective {@link AttendeeConnectedEvent}
-		 */
-		const allAttendeesJoinedTimeoutMs = (1000 + 200 * numClients) * timeoutMultiplier;
-		/**
-		 * Timeout for presence attendees to fully join (everyone knows about everyone) {@link AttendeeConnectedEvent}
-		 */
-		const allAttendeesFullyJoinedTimeoutMs = (2000 + 300 * numClients) * timeoutMultiplier;
+	describe("`attendees` support", () => {
+		const numClientsForAttendeeTests = [5, 40, 100, 250];
+		for (const numClients of numClientsForAttendeeTests) {
+			if (numClients > 50 && !shouldRunScaleTests) {
+				testConsole.log(
+					`skipping Presence attendee scale tests with ${numClients} clients (set FLUID_TEST_SCALE=true to run)`,
+				);
+				continue;
+			}
 
-		for (const writeClients of [numClients, 1]) {
-			it(`announces 'attendeeConnected' when remote client joins session [${numClients} clients, ${writeClients} writers]`, async function () {
-				// AB#48866: Fix intermittently failing presence tests
-				if (useAzure) {
-					this.skip();
-				}
+			assert(numClients > 1, "Must have at least two clients");
+			/**
+			 * Timeout for child processes to connect to container ({@link ConnectedEvent})
+			 */
+			const childConnectTimeoutMs = 1000 * numClients * timeoutMultiplier;
+			/**
+			 * Timeout for presence attendees to join per first child perspective {@link AttendeeConnectedEvent}
+			 */
+			const allAttendeesJoinedTimeoutMs = (1000 + 200 * numClients) * timeoutMultiplier;
+			/**
+			 * Timeout for presence attendees to fully join (everyone knows about everyone) {@link AttendeeConnectedEvent}
+			 */
+			const allAttendeesFullyJoinedTimeoutMs = (2000 + 300 * numClients) * timeoutMultiplier;
+
+			for (const writeClients of [numClients, 1]) {
+				it(`announces 'attendeeConnected' when remote client joins session [${numClients} clients, ${writeClients} writers]`, async function testAnnouncesAttendeeConnected() {
+					setTestTimeout(this, childConnectTimeoutMs + allAttendeesJoinedTimeoutMs + 1000);
 
-				setTestTimeout(this, childConnectTimeoutMs + allAttendeesJoinedTimeoutMs + 1000);
+					// Setup
+					const { children, childErrorPromise } = await forkChildProcesses(
+						this.test?.title ?? "",
+						numClients,
+						afterCleanUp,
+					);
 
-				// Setup
-				const { children, childErrorPromise } = await forkChildProcesses(
-					numClients,
-					afterCleanUp,
-				);
+					// Further Setup with Act and Verify
+					await connectAndWaitForAttendees(
+						children,
+						{
+							writeClients,
+							attendeeCountRequired: numClients - 1,
+							childConnectTimeoutMs,
+							allAttendeesJoinedTimeoutMs,
+						},
+						childErrorPromise,
+					);
+				});
+
+				it(`announces 'attendeeDisconnected' when remote client disconnects [${numClients} clients, ${writeClients} writers]`, async function testAnnouncesAttendeeDisconnected() {
+					if (useAzure && numClients > 50) {
+						// Even with increased timeouts, more than 50 clients can be too large for AFR.
+						// This may be due to slow responses/inactivity from the clients that are
+						// creating pressure on ADO agent.
+						this.skip();
+					}
 
-				// Further Setup with Act and Verify
-				await connectAndWaitForAttendees(
-					children,
-					{
+					const childDisconnectTimeoutMs = 10_000 * timeoutMultiplier;
+
+					setTestTimeout(
+						this,
+						childConnectTimeoutMs +
+							allAttendeesFullyJoinedTimeoutMs +
+							childDisconnectTimeoutMs +
+							1000,
+					);
+
+					// Setup
+					const { children, childErrorPromise } = await forkChildProcesses(
+						this.test?.title ?? "",
+						numClients,
+						afterCleanUp,
+					);
+
+					const startConnectAndFullJoin = performance.now();
+					const connectResult = await connectAndListenForAttendees(children, {
 						writeClients,
 						attendeeCountRequired: numClients - 1,
 						childConnectTimeoutMs,
-						allAttendeesJoinedTimeoutMs,
-					},
-					childErrorPromise,
-				);
-			});
-
-			// Even at 5 clients reaching fully connected state is unreliable with current implementation.
-			it.skip(`announces 'attendeeDisconnected' when remote client disconnects [${numClients} clients, ${writeClients} writers]`, async function () {
-				// TODO: AB#45620: "Presence: perf: update Join pattern for scale" can handle
-				// larger counts of read-only attendees. Without protocol changes tests with
-				// 20+ attendees exceed current limits.
-				if (numClients >= 20 && writeClients === 1) {
-					this.skip();
-				}
-
-				if (useAzure && numClients > 50) {
-					// Even with increased timeouts, more than 50 clients can be too large for AFR.
-					// This may be due to slow responses/inactivity from the clients that are
-					// creating pressure on ADO agent.
-					this.skip();
-				}
-
-				const childDisconnectTimeoutMs = 10_000 * timeoutMultiplier;
-
-				setTestTimeout(
-					this,
-					childConnectTimeoutMs +
-						allAttendeesFullyJoinedTimeoutMs +
-						childDisconnectTimeoutMs +
-						1000,
-				);
-
-				// Setup
-				const { children, childErrorPromise } = await forkChildProcesses(
-					numClients,
-					afterCleanUp,
-				);
-
-				const startConnectAndFullJoin = performance.now();
-				const connectResult = await connectAndListenForAttendees(children, {
-					writeClients,
-					attendeeCountRequired: numClients - 1,
-					childConnectTimeoutMs,
-				});
-				// eslint-disable-next-line @typescript-eslint/no-floating-promises
-				connectResult.attendeeCountRequiredPromises[0].then(() =>
-					testConsole.log(
-						`[${new Date().toISOString()}] All attendees joined per child 0 after ${performance.now() - startConnectAndFullJoin}ms`,
-					),
-				);
+					});
+					// eslint-disable-next-line @typescript-eslint/no-floating-promises
+					connectResult.attendeeCountRequiredPromises[0].then(() =>
+						testConsole.log(
+							`[${new Date().toISOString()}] All attendees joined per child 0 after ${performance.now() - startConnectAndFullJoin}ms`,
+						),
+					);
 
-				// Wait for all attendees to be fully joined
-				// Keep a tally for debuggability
-				let childrenFullyJoined = 0;
-				const setNotFullyJoined = new Set<number>();
-				for (let i = 0; i < children.length; i++) {
-					setNotFullyJoined.add(i);
-				}
-				const allAttendeesFullyJoined = Promise.all(
-					connectResult.attendeeCountRequiredPromises.map(
-						async (attendeeFullyJoinedPromise, index) => {
-							await attendeeFullyJoinedPromise;
-							childrenFullyJoined++;
-							setNotFullyJoined.delete(index);
-						},
-					),
-				);
-				let timedout = true;
-				const allFullyJoinedOrChildError = Promise.race([
-					allAttendeesFullyJoined,
-					childErrorPromise,
-				]).finally(() => (timedout = false));
-				await timeoutAwait(allFullyJoinedOrChildError, {
-					durationMs: allAttendeesFullyJoinedTimeoutMs,
-					errorMsg: "Not all attendees fully joined",
-				}).catch(async (error) => {
-					// Ideally this information would just be in the timeout error message, but that
-					// must be a resolved string (not dynamic). So, just log it separately.
-					testConsole.log(
-						`[${new Date().toISOString()}] ${childrenFullyJoined} attendees fully joined before error...`,
+					// Wait for all attendees to be fully joined
+					// Keep a tally for debuggability
+					let childrenFullyJoined = 0;
+					const setNotFullyJoined = new Set<number>();
+					for (let i = 0; i < children.length; i++) {
+						setNotFullyJoined.add(i);
+					}
+					const allAttendeesFullyJoined = Promise.all(
+						connectResult.attendeeCountRequiredPromises.map(
+							async (attendeeFullyJoinedPromise, index) => {
+								await attendeeFullyJoinedPromise;
+								childrenFullyJoined++;
+								setNotFullyJoined.delete(index);
+							},
+						),
 					);
-					if (timedout) {
-						// Gather additional timing data if timed out to understand what increased
-						// timeout could work. Test will still fail if this secondary wait succeeds.
-						const startAdditionalWait = performance.now();
-						try {
-							await timeoutAwait(allFullyJoinedOrChildError, {
-								durationMs: allAttendeesFullyJoinedTimeoutMs,
-							});
-							testConsole.log(
-								`[${new Date().toISOString()}] All attendees fully joined after additional wait (${performance.now() - startAdditionalWait}ms)`,
-							);
-						} catch (secondaryError) {
-							testConsole.log(
-								`[${new Date().toISOString()}] Secondary await resulted in`,
-								secondaryError,
-							);
+					let timedout = true;
+					const allFullyJoinedOrChildError = Promise.race([
+						allAttendeesFullyJoined,
+						childErrorPromise,
+					]).finally(() => (timedout = false));
+					await timeoutAwait(allFullyJoinedOrChildError, {
+						durationMs: allAttendeesFullyJoinedTimeoutMs,
+						errorMsg: "Not all attendees fully joined",
+					}).catch(async (error) => {
+						// Ideally this information would just be in the timeout error message, but that
+						// must be a resolved string (not dynamic). So, just log it separately.
+						testConsole.log(
+							`[${new Date().toISOString()}] ${childrenFullyJoined} attendees fully joined before error...`,
+						);
+						if (timedout) {
+							// Gather additional timing data if timed out to understand what increased
+							// timeout could work. Test will still fail if this secondary wait succeeds.
+							const startAdditionalWait = performance.now();
+							try {
+								await timeoutAwait(allFullyJoinedOrChildError, {
+									durationMs: allAttendeesFullyJoinedTimeoutMs,
+								});
+								testConsole.log(
+									`[${new Date().toISOString()}] All attendees fully joined after additional wait (${performance.now() - startAdditionalWait}ms)`,
+								);
+							} catch (secondaryError) {
+								testConsole.log(
+									`[${new Date().toISOString()}] Secondary await resulted in`,
+									secondaryError,
+								);
+							}
 						}
-					}
 
-					// Gather and report debug info from children
-					// If there are less than 10 children, get all reports.
-					// Otherwise, just child 0 and those not fully joined.
-					setTestTimeout(this, 0); // Disable test timeout. Will throw within 20s below.
-					const childrenRequestedToReport =
-						children.length <= 10
-							? children
-							: // Just those not fully joined
-								children.filter((_, index) => index === 0 || setNotFullyJoined.has(index));
-					await timeoutAwait(
-						Promise.race([executeDebugReports(childrenRequestedToReport), childErrorPromise]),
-						{ durationMs: 20_000, errorMsg: "Debug report timeout" },
-					).catch((debugAwaitError) => {
-						testConsole.error("Debug report await resulted in", debugAwaitError);
-					});
+						// Gather and report debug info from children
+						// If there are less than 10 children, get all reports.
+						// Otherwise, just child 0 and those not fully joined.
+						setTestTimeout(this, 0); // Disable test timeout. Will throw within 20s below.
+						const childrenRequestedToReport =
+							children.length <= 10
+								? children
+								: // Just those not fully joined
+									children.filter((_, index) => index === 0 || setNotFullyJoined.has(index));
+						await timeoutAwait(
+							Promise.race([
+								executeDebugReports(childrenRequestedToReport),
+								childErrorPromise,
+							]),
+							{ durationMs: 20_000, errorMsg: "Debug report timeout" },
+						).catch((debugAwaitError) => {
+							testConsole.error("Debug report await resulted in", debugAwaitError);
+						});
 
-					throw error;
-				});
-				testConsole.log(
-					`[${new Date().toISOString()}] All attendees fully joined after ${performance.now() - startConnectAndFullJoin}ms`,
-				);
+						throw error;
+					});
+					testConsole.log(
+						`[${new Date().toISOString()}] All attendees fully joined after ${performance.now() - startConnectAndFullJoin}ms`,
+					);
 
-				let child0ReportRequested = false;
-				const waitForDisconnected = children.map(async (child, index) =>
-					index === 0
-						? Promise.resolve()
-						: timeoutPromise(
-								(resolve) => {
-									child.on("message", (msg: MessageFromChild) => {
-										if (
-											msg.event === "attendeeDisconnected" &&
-											msg.attendeeId === connectResult.containerCreatorAttendeeId
-										) {
-											console.log(`Child[${index}] saw creator disconnect`);
-											resolve();
-										}
+					let child0ReportRequested = false;
+					const waitForDisconnected = children.map(async (child, index) =>
+						index === 0
+							? Promise.resolve()
+							: timeoutPromise(
+									(resolve) => {
+										child.on("message", (msg: MessageFromChild) => {
+											if (
+												msg.event === "attendeeDisconnected" &&
+												msg.attendeeId === connectResult.containerCreatorAttendeeId
+											) {
+												console.log(`Child[${index}] saw creator disconnect`);
+												resolve();
+											}
+										});
+									},
+									{
+										durationMs: childDisconnectTimeoutMs,
+										errorMsg: `Attendee[${index}] Disconnected Timeout`,
+									},
+								).catch(async (error) => {
+									const childrenRequestedToReport = [child];
+									if (!child0ReportRequested) {
+										childrenRequestedToReport.unshift(children[0]);
+										child0ReportRequested = true;
+									}
+									await timeoutAwait(
+										Promise.race([
+											executeDebugReports(childrenRequestedToReport),
+											childErrorPromise,
+										]),
+										{ durationMs: 20_000, errorMsg: "Debug report timeout" },
+									).catch((debugAwaitError) => {
+										testConsole.error("Debug report await resulted in", debugAwaitError);
 									});
-								},
-								{
-									durationMs: childDisconnectTimeoutMs,
-									errorMsg: `Attendee[${index}] Disconnected Timeout`,
-								},
-							).catch(async (error) => {
-								const childrenRequestedToReport = [child];
-								if (!child0ReportRequested) {
-									childrenRequestedToReport.unshift(children[0]);
-									child0ReportRequested = true;
-								}
-								await timeoutAwait(
-									Promise.race([
-										executeDebugReports(childrenRequestedToReport),
-										childErrorPromise,
-									]),
-									{ durationMs: 20_000, errorMsg: "Debug report timeout" },
-								).catch((debugAwaitError) => {
-									testConsole.error("Debug report await resulted in", debugAwaitError);
-								});
-								throw error;
-							}),
-				);
+									throw error;
+								}),
+					);
 
-				// Act - disconnect first child process
-				children[0].send({ command: "disconnectSelf" });
+					// Act - disconnect first child process
+					children[0].send({ command: "disconnectSelf" });
 
-				// Verify - wait for all 'attendeeDisconnected' events
-				await Promise.race([Promise.all(waitForDisconnected), childErrorPromise]);
-			});
+					// Verify - wait for all 'attendeeDisconnected' events
+					await Promise.race([Promise.all(waitForDisconnected), childErrorPromise]);
+				});
+			}
 		}
-	}
+	});
 
 	{
 		/**
@@ -330,82 +337,95 @@ describe(`Presence with AzureClient`, () => {
 				/**
 				 * Timeout for child processes to connect to container ({@link ConnectedEvent})
 				 */
-				const childConnectTimeoutMs = 1000 * numClients * timeoutMultiplier;
-
-				let children: ChildProcess[];
-				let childErrorPromise: Promise<never>;
-				let containerCreatorAttendeeId: AttendeeId;
-				let attendeeIdPromises: Promise<AttendeeId>[];
-				let remoteClients: ChildProcess[];
-				const testValue = "testValue";
-				const workspaceId = "presenceTestWorkspace";
-
-				beforeEach(async () => {
-					({ children, childErrorPromise } = await forkChildProcesses(
-						numClients,
-						afterCleanUp,
-					));
-					({ containerCreatorAttendeeId, attendeeIdPromises } = await connectChildProcesses(
-						children,
-						{ writeClients: numClients, readyTimeoutMs: childConnectTimeoutMs },
-					));
-					await Promise.all(attendeeIdPromises);
-					remoteClients = children.filter((_, index) => index !== 0);
-					// NOTE: For testing purposes child clients will expect a Latest value of type string (StateFactory.latest<{ value: string }>).
-					await registerWorkspaceOnChildren(children, workspaceId, {
-						latest: true,
-						timeoutMs: workspaceRegisterTimeoutMs,
-					});
-				});
-
-				it(`allows clients to read Latest state from other clients [${numClients} clients]`, async function () {
-					// AB#48866: Fix intermittently failing presence tests
-					if (useAzure) {
-						this.skip();
-					}
-					// Setup
-					const updateEventsPromise = waitForLatestValueUpdates(
-						remoteClients,
-						workspaceId,
-						childErrorPromise,
-						stateUpdateTimeoutMs,
-						{ fromAttendeeId: containerCreatorAttendeeId, expectedValue: testValue },
-					);
+				const childConnectTimeoutMs = (4000 + 1000 * numClients) * timeoutMultiplier;
+				const testCaseTimeoutMs = 1000;
+				const testSetupAndActTimeoutMs = childConnectTimeoutMs + testCaseTimeoutMs;
+
+				// These tests use beforeEach to setup complex state that takes a lot of time
+				// and is dependent on number of clients. Keeping the work in beforeEach
+				// allows time reporting to report the tested scenario apart from the setup time.
+				// So this describe block isolates those beforeEach setups from each distinct
+				// client count. Test cases descriptions also have the client count for clarity.
+				describe(`with ${numClients} clients`, () => {
+					let children: ChildProcess[];
+					let childErrorPromise: Promise<never>;
+					let containerCreatorAttendeeId: AttendeeId;
+					let attendeeIdPromises: Promise<AttendeeId>[];
+					let remoteClients: ChildProcess[];
+					const testValue = "testValue";
+					const workspaceId = "presenceTestWorkspace";
+
+					beforeEach(async function usingLatestStateObject_beforeEach(): Promise<void> {
+						const startTime = performance.now();
+						setTestTimeout(this, testSetupAndActTimeoutMs);
+
+						({ children, childErrorPromise } = await forkChildProcesses(
+							this.currentTest?.title ?? "",
+							numClients,
+							afterCleanUp,
+						));
+						({ containerCreatorAttendeeId, attendeeIdPromises } = await connectChildProcesses(
+							children,
+							{ writeClients: numClients, readyTimeoutMs: childConnectTimeoutMs },
+						));
+						await Promise.all(attendeeIdPromises);
+						remoteClients = children.filter((_, index) => index !== 0);
+						// NOTE: For testing purposes child clients will expect a Latest value of type string (StateFactory.latest<{ value: string }>).
+						await registerWorkspaceOnChildren(children, workspaceId, {
+							latest: true,
+							timeoutMs: workspaceRegisterTimeoutMs,
+						});
 
-					// Act - Trigger the update
-					children[0].send({
-						command: "setLatestValue",
-						workspaceId,
-						value: testValue,
+						testConsole.log(
+							`  Setup for "${this.currentTest?.title}" completed in ${performance.now() - startTime}ms`,
+						);
 					});
-					const updateEvents = await updateEventsPromise;
 
-					// Verify all events are from the expected attendee
-					for (const updateEvent of updateEvents) {
-						assert.strictEqual(updateEvent.attendeeId, containerCreatorAttendeeId);
-						assert.deepStrictEqual(updateEvent.value, testValue);
-					}
-
-					// Act - Request each remote client to read latest state from container creator
-					for (const child of remoteClients) {
-						child.send({
-							command: "getLatestValue",
+					it(`allows clients to read Latest state from other clients [${numClients} clients]`, async function () {
+						// Setup
+						const updateEventsPromise = waitForLatestValueUpdates(
+							remoteClients,
+							workspaceId,
+							childErrorPromise,
+							stateUpdateTimeoutMs,
+							{ fromAttendeeId: containerCreatorAttendeeId, expectedValue: testValue },
+						);
+
+						// Act - Trigger the update
+						children[0].send({
+							command: "setLatestValue",
 							workspaceId,
-							attendeeId: containerCreatorAttendeeId,
+							value: testValue,
 						});
-					}
+						const updateEvents = await updateEventsPromise;
 
-					const getResponses = await getLatestValueResponses(
-						remoteClients,
-						workspaceId,
-						childErrorPromise,
-						getStateTimeoutMs,
-					);
+						// Verify all events are from the expected attendee
+						for (const updateEvent of updateEvents) {
+							assert.strictEqual(updateEvent.attendeeId, containerCreatorAttendeeId);
+							assert.deepStrictEqual(updateEvent.value, testValue);
+						}
 
-					// Verify - all responses should contain the expected value
-					for (const getResponse of getResponses) {
-						assert.deepStrictEqual(getResponse.value, testValue);
-					}
+						// Act - Request each remote client to read latest state from container creator
+						for (const child of remoteClients) {
+							child.send({
+								command: "getLatestValue",
+								workspaceId,
+								attendeeId: containerCreatorAttendeeId,
+							});
+						}
+
+						const getResponses = await getLatestValueResponses(
+							remoteClients,
+							workspaceId,
+							childErrorPromise,
+							getStateTimeoutMs,
+						);
+
+						// Verify - all responses should contain the expected value
+						for (const getResponse of getResponses) {
+							assert.deepStrictEqual(getResponse.value, testValue);
+						}
+					});
 				});
 			}
 		});
@@ -418,197 +438,211 @@ describe(`Presence with AzureClient`, () => {
 				/**
 				 * Timeout for child processes to connect to container ({@link ConnectedEvent})
 				 */
-				const childConnectTimeoutMs = 1000 * numClients * timeoutMultiplier;
-
-				let children: ChildProcess[];
-				let childErrorPromise: Promise<never>;
-				let containerCreatorAttendeeId: AttendeeId;
-				let attendeeIdPromises: Promise<AttendeeId>[];
-				let remoteClients: ChildProcess[];
-				const workspaceId = "presenceTestWorkspace";
-				const key1 = "player1";
-				const key2 = "player2";
-				const value1 = { name: "Alice", score: 100 };
-				const value2 = { name: "Bob", score: 200 };
-
-				beforeEach(async () => {
-					({ children, childErrorPromise } = await forkChildProcesses(
-						numClients,
-						afterCleanUp,
-					));
-					({ containerCreatorAttendeeId, attendeeIdPromises } = await connectChildProcesses(
-						children,
-						{ writeClients: numClients, readyTimeoutMs: childConnectTimeoutMs },
-					));
-					await Promise.all(attendeeIdPromises);
-					remoteClients = children.filter((_, index) => index !== 0);
-					// NOTE: For testing purposes child clients will expect a LatestMap value of type Record<string, string | number> (StateFactory.latestMap<{ value: Record<string, string | number> }, string>).
-					await registerWorkspaceOnChildren(children, workspaceId, {
-						latestMap: true,
-						timeoutMs: workspaceRegisterTimeoutMs,
-					});
-				});
-
-				it(`allows clients to read LatestMap values from other clients [${numClients} clients]`, async () => {
-					// Setup
-					const testKey = "cursor";
-					const testValue = { x: 150, y: 300 };
-					const updateEventsPromise = waitForLatestMapValueUpdates(
-						remoteClients,
-						workspaceId,
-						testKey,
-						childErrorPromise,
-						stateUpdateTimeoutMs,
-						{ fromAttendeeId: containerCreatorAttendeeId, expectedValue: testValue },
-					);
+				const childConnectTimeoutMs = (4000 + 1000 * numClients) * timeoutMultiplier;
+				const testCaseTimeoutMs = 1000;
+				const testSetupAndActTimeoutMs = childConnectTimeoutMs + testCaseTimeoutMs;
+
+				// These tests use beforeEach to setup complex state that takes a lot of time
+				// and is dependent on number of clients. Keeping the work in beforeEach
+				// allows time reporting to report the tested scenario apart from the setup time.
+				// So this describe block isolates those beforeEach setups from each distinct
+				// client count. Test cases descriptions also have the client count for clarity.
+				describe(`with ${numClients} clients`, () => {
+					let children: ChildProcess[];
+					let childErrorPromise: Promise<never>;
+					let containerCreatorAttendeeId: AttendeeId;
+					let attendeeIdPromises: Promise<AttendeeId>[];
+					let remoteClients: ChildProcess[];
+					const workspaceId = "presenceTestWorkspace";
+					const key1 = "player1";
+					const key2 = "player2";
+					const value1 = { name: "Alice", score: 100 };
+					const value2 = { name: "Bob", score: 200 };
+
+					beforeEach(async function usingLatestMapStateObject_beforeEach(): Promise<void> {
+						const startTime = performance.now();
+
+						setTestTimeout(this, testSetupAndActTimeoutMs);
+
+						({ children, childErrorPromise } = await forkChildProcesses(
+							this.currentTest?.title ?? "",
+							numClients,
+							afterCleanUp,
+						));
+						({ containerCreatorAttendeeId, attendeeIdPromises } = await connectChildProcesses(
+							children,
+							{ writeClients: numClients, readyTimeoutMs: childConnectTimeoutMs },
+						));
+						await Promise.all(attendeeIdPromises);
+						remoteClients = children.filter((_, index) => index !== 0);
+						// NOTE: For testing purposes child clients will expect a LatestMap value of type Record<string, string | number> (StateFactory.latestMap<{ value: Record<string, string | number> }, string>).
+						await registerWorkspaceOnChildren(children, workspaceId, {
+							latestMap: true,
+							timeoutMs: workspaceRegisterTimeoutMs,
+						});
 
-					// Act
-					children[0].send({
-						command: "setLatestMapValue",
-						workspaceId,
-						key: testKey,
-						value: testValue,
+						testConsole.log(
+							`  Setup for "${this.currentTest?.title}" completed in ${performance.now() - startTime}ms`,
+						);
 					});
-					const updateEvents = await updateEventsPromise;
 
-					// Check all events are from the expected attendee
-					for (const updateEvent of updateEvents) {
-						assert.strictEqual(updateEvent.attendeeId, containerCreatorAttendeeId);
-						assert.strictEqual(updateEvent.key, testKey);
-						assert.deepStrictEqual(updateEvent.value, testValue);
-					}
-
-					for (const child of remoteClients) {
-						child.send({
-							command: "getLatestMapValue",
+					it(`allows clients to read LatestMap values from other clients [${numClients} clients]`, async () => {
+						// Setup
+						const testKey = "cursor";
+						const testValue = { x: 150, y: 300 };
+						const updateEventsPromise = waitForLatestMapValueUpdates(
+							remoteClients,
+							workspaceId,
+							testKey,
+							childErrorPromise,
+							stateUpdateTimeoutMs,
+							{ fromAttendeeId: containerCreatorAttendeeId, expectedValue: testValue },
+						);
+
+						// Act
+						children[0].send({
+							command: "setLatestMapValue",
 							workspaceId,
 							key: testKey,
-							attendeeId: containerCreatorAttendeeId,
+							value: testValue,
 						});
-					}
-					const getResponses = await getLatestMapValueResponses(
-						remoteClients,
-						workspaceId,
-						testKey,
-						childErrorPromise,
-						getStateTimeoutMs,
-					);
+						const updateEvents = await updateEventsPromise;
 
-					// Verify
-					for (const getResponse of getResponses) {
-						assert.deepStrictEqual(getResponse.value, testValue);
-					}
-				});
-
-				it(`returns per-key values on read [${numClients} clients]`, async function () {
-					// AB#48866: Fix intermittently failing presence tests
-					if (useAzure) {
-						this.skip();
-					}
-					// Setup
-					const allAttendeeIds = await Promise.all(attendeeIdPromises);
-					const attendee0Id = containerCreatorAttendeeId;
-					const attendee1Id = allAttendeeIds[1];
-
-					const key1Recipients = children.filter((_, index) => index !== 0);
-					const key2Recipients = children.filter((_, index) => index !== 1);
-					const key1UpdateEventsPromise = waitForLatestMapValueUpdates(
-						key1Recipients,
-						workspaceId,
-						key1,
-						childErrorPromise,
-						stateUpdateTimeoutMs,
-						{ fromAttendeeId: attendee0Id, expectedValue: value1 },
-					);
-					const key2UpdateEventsPromise = waitForLatestMapValueUpdates(
-						key2Recipients,
-						workspaceId,
-						key2,
-						childErrorPromise,
-						stateUpdateTimeoutMs,
-						{ fromAttendeeId: attendee1Id, expectedValue: value2 },
-					);
+						// Check all events are from the expected attendee
+						for (const updateEvent of updateEvents) {
+							assert.strictEqual(updateEvent.attendeeId, containerCreatorAttendeeId);
+							assert.strictEqual(updateEvent.key, testKey);
+							assert.deepStrictEqual(updateEvent.value, testValue);
+						}
 
-					// Act
-					children[0].send({
-						command: "setLatestMapValue",
-						workspaceId,
-						key: key1,
-						value: value1,
-					});
-					const key1UpdateEvents = await key1UpdateEventsPromise;
-					children[1].send({
-						command: "setLatestMapValue",
-						workspaceId,
-						key: key2,
-						value: value2,
+						for (const child of remoteClients) {
+							child.send({
+								command: "getLatestMapValue",
+								workspaceId,
+								key: testKey,
+								attendeeId: containerCreatorAttendeeId,
+							});
+						}
+						const getResponses = await getLatestMapValueResponses(
+							remoteClients,
+							workspaceId,
+							testKey,
+							childErrorPromise,
+							getStateTimeoutMs,
+						);
+
+						// Verify
+						for (const getResponse of getResponses) {
+							assert.deepStrictEqual(getResponse.value, testValue);
+						}
 					});
-					const key2UpdateEvents = await key2UpdateEventsPromise;
 
-					// Verify all events are from the expected attendees
-					for (const updateEvent of key1UpdateEvents) {
-						assert.strictEqual(updateEvent.attendeeId, attendee0Id);
-						assert.strictEqual(updateEvent.key, key1);
-						assert.deepStrictEqual(updateEvent.value, value1);
-					}
-					for (const updateEvent of key2UpdateEvents) {
-						assert.strictEqual(updateEvent.attendeeId, attendee1Id);
-						assert.strictEqual(updateEvent.key, key2);
-						assert.deepStrictEqual(updateEvent.value, value2);
-					}
+					it(`returns per-key values on read [${numClients} clients]`, async function () {
+						// Setup
+						const allAttendeeIds = await Promise.all(attendeeIdPromises);
+						const attendee0Id = containerCreatorAttendeeId;
+						const attendee1Id = allAttendeeIds[1];
 
-					// Read key1 of attendee0 from all children
-					for (const child of children) {
-						child.send({
-							command: "getLatestMapValue",
+						const key1Recipients = children.filter((_, index) => index !== 0);
+						const key2Recipients = children.filter((_, index) => index !== 1);
+						const key1UpdateEventsPromise = waitForLatestMapValueUpdates(
+							key1Recipients,
+							workspaceId,
+							key1,
+							childErrorPromise,
+							stateUpdateTimeoutMs,
+							{ fromAttendeeId: attendee0Id, expectedValue: value1 },
+						);
+						const key2UpdateEventsPromise = waitForLatestMapValueUpdates(
+							key2Recipients,
+							workspaceId,
+							key2,
+							childErrorPromise,
+							stateUpdateTimeoutMs,
+							{ fromAttendeeId: attendee1Id, expectedValue: value2 },
+						);
+
+						// Act
+						children[0].send({
+							command: "setLatestMapValue",
 							workspaceId,
 							key: key1,
-							attendeeId: attendee0Id,
+							value: value1,
 						});
-					}
-					const key1Responses = await getLatestMapValueResponses(
-						children,
-						workspaceId,
-						key1,
-						childErrorPromise,
-						getStateTimeoutMs,
-					);
-
-					// Read key2 of attendee1 from all children
-					for (const child of children) {
-						child.send({
-							command: "getLatestMapValue",
+						const key1UpdateEvents = await key1UpdateEventsPromise;
+						children[1].send({
+							command: "setLatestMapValue",
 							workspaceId,
 							key: key2,
-							attendeeId: attendee1Id,
+							value: value2,
 						});
-					}
-					const key2Responses = await getLatestMapValueResponses(
-						children,
-						workspaceId,
-						key2,
-						childErrorPromise,
-						getStateTimeoutMs,
-					);
+						const key2UpdateEvents = await key2UpdateEventsPromise;
 
-					// Verify
-					assert.strictEqual(
-						key1Responses.length,
-						numClients,
-						"Expected responses from all clients for key1",
-					);
-					assert.strictEqual(
-						key2Responses.length,
-						numClients,
-						"Expected responses from all clients for key2",
-					);
+						// Verify all events are from the expected attendees
+						for (const updateEvent of key1UpdateEvents) {
+							assert.strictEqual(updateEvent.attendeeId, attendee0Id);
+							assert.strictEqual(updateEvent.key, key1);
+							assert.deepStrictEqual(updateEvent.value, value1);
+						}
+						for (const updateEvent of key2UpdateEvents) {
+							assert.strictEqual(updateEvent.attendeeId, attendee1Id);
+							assert.strictEqual(updateEvent.key, key2);
+							assert.deepStrictEqual(updateEvent.value, value2);
+						}
 
-					for (const response of key1Responses) {
-						assert.deepStrictEqual(response.value, value1, "Key1 value should match");
-					}
-					for (const response of key2Responses) {
-						assert.deepStrictEqual(response.value, value2, "Key2 value should match");
-					}
+						// Read key1 of attendee0 from all children
+						for (const child of children) {
+							child.send({
+								command: "getLatestMapValue",
+								workspaceId,
+								key: key1,
+								attendeeId: attendee0Id,
+							});
+						}
+						const key1Responses = await getLatestMapValueResponses(
+							children,
+							workspaceId,
+							key1,
+							childErrorPromise,
+							getStateTimeoutMs,
+						);
+
+						// Read key2 of attendee1 from all children
+						for (const child of children) {
+							child.send({
+								command: "getLatestMapValue",
+								workspaceId,
+								key: key2,
+								attendeeId: attendee1Id,
+							});
+						}
+						const key2Responses = await getLatestMapValueResponses(
+							children,
+							workspaceId,
+							key2,
+							childErrorPromise,
+							getStateTimeoutMs,
+						);
+
+						// Verify
+						assert.strictEqual(
+							key1Responses.length,
+							numClients,
+							"Expected responses from all clients for key1",
+						);
+						assert.strictEqual(
+							key2Responses.length,
+							numClients,
+							"Expected responses from all clients for key2",
+						);
+
+						for (const response of key1Responses) {
+							assert.deepStrictEqual(response.value, value1, "Key1 value should match");
+						}
+						for (const response of key2Responses) {
+							assert.deepStrictEqual(response.value, value2, "Key2 value should match");
+						}
+					});
 				});
 			}
 		});