@fluidframework/test-utils 2.0.0-dev.3.1.0.125672 → 2.0.0-dev.4.2.0.153917

package/src/testObjectProvider.ts

@@ -3,7 +3,13 @@
  * Licensed under the MIT License.
  */
 
-import { IContainer, IHostLoader, IFluidCodeDetails } from "@fluidframework/container-definitions";
+import {
+	IContainer,
+	IHostLoader,
+	IFluidCodeDetails,
+	LoaderHeader,
+	ILoader,
+} from "@fluidframework/container-definitions";
 import {
 	ITelemetryGenericEvent,
 	ITelemetryBaseLogger,
@@ -107,6 +113,9 @@ export interface ITestContainerConfig {
 
 	/** Loader options for the loader used to create containers */
 	loaderProps?: Partial<ILoaderProps>;
+
+	/** Temporary flag: simulate read connection using delay connection, default is true */
+	simulateReadConnectionUsingDelay?: boolean;
 }
 
 export const createDocumentId = (): string => uuid();
@@ -154,10 +163,18 @@ function getDocumentIdStrategy(type?: TestDriverTypes): IDocumentIdStrategy {
  * any expected events that have not occurred.
  */
 export class EventAndErrorTrackingLogger extends TelemetryLogger {
-	/** Even if these error events are logged, tests should still be allowed to pass */
-	private readonly allowedErrors: string[] = [
+	/**
+	 * Even if these error events are logged, tests should still be allowed to pass
+	 * Additionally, if downgrade is true, then log as generic (e.g. to avoid polluting the e2e test logs)
+	 */
+	private readonly allowedErrors: { eventName: string; downgrade?: true }[] = [
 		// This log was removed in current version as unnecessary, but it's still present in previous versions
-		"fluid:telemetry:Container:NoRealStorageInDetachedContainer",
+		{
+			eventName: "fluid:telemetry:Container:NoRealStorageInDetachedContainer",
+			downgrade: true,
+		},
+		// This log's category changes depending on the op latency. test results shouldn't be affected but if we see lots we'd like an alert from the logs.
+		{ eventName: "fluid:telemetry:OpPerf:OpRoundtripTime" },
 	];
 
 	constructor(private readonly baseLogger: ITelemetryBaseLogger) {
@@ -207,10 +224,15 @@ export class EventAndErrorTrackingLogger extends TelemetryLogger {
 			}
 		}
 		if (event.category === "error") {
-			if (this.allowedErrors.includes(event.eventName)) {
-				event.category = "generic";
-			} else {
+			// Check to see if this error is allowed and if its category should be downgraded
+			const allowedError = this.allowedErrors.find(
+				({ eventName }) => eventName === event.eventName,
+			);
+
+			if (allowedError === undefined) {
 				this.unexpectedErrors.push(event);
+			} else if (allowedError.downgrade) {
+				event.category = "generic";
 			}
 		}
 
@@ -364,10 +386,44 @@ export class TestObjectProvider implements ITestObjectProvider {
 		requestHeader?: IRequestHeader,
 	): Promise<IContainer> {
 		const loader = this.createLoader([[defaultCodeDetails, entryPoint]], loaderProps);
-		return loader.resolve({
+		return this.resolveContainer(loader, requestHeader);
+	}
+
+	private async resolveContainer(
+		loader: ILoader,
+		requestHeader?: IRequestHeader,
+		delay: boolean = true,
+	) {
+		// Once AB#3889 is done to switch default connection mode to "read" on load, we don't need
+		// to load "delayed" across the board. Remove the following code.
+		const delayConnection =
+			delay &&
+			(requestHeader === undefined || requestHeader[LoaderHeader.reconnect] !== false);
+		const headers: IRequestHeader | undefined = delayConnection
+			? {
+					[LoaderHeader.loadMode]: { deltaConnection: "delayed" },
+					...requestHeader,
+			  }
+			: requestHeader;
+
+		const container = await loader.resolve({
 			url: await this.driver.createContainerUrl(this.documentId),
-			headers: requestHeader,
+			headers,
 		});
+
+		// Once AB#3889 is done to switch default connection mode to "read" on load, we don't need
+		// to load "delayed" across the board. Remove the following code.
+		if (delayConnection) {
+			// Older version may not have connect/disconnect. It was add in PR#9439, and available >= 0.59.1000
+			const maybeContainer = container as Partial<IContainer>;
+			if (maybeContainer.connect !== undefined) {
+				container.connect();
+			} else {
+				// back compat. Remove when we don't support < 0.59.1000
+				(container as any).resume();
+			}
+		}
+		return container;
 	}
 
 	/**
@@ -419,10 +475,12 @@ export class TestObjectProvider implements ITestObjectProvider {
 		requestHeader?: IRequestHeader,
 	): Promise<IContainer> {
 		const loader = this.makeTestLoader(testContainerConfig);
-		const container = await loader.resolve({
-			url: await this.driver.createContainerUrl(this.documentId),
-			headers: requestHeader,
-		});
+
+		const container = await this.resolveContainer(
+			loader,
+			requestHeader,
+			testContainerConfig?.simulateReadConnectionUsingDelay,
+		);
 		await this.waitContainerToCatchUp(container);
 
 		return container;
@@ -442,9 +500,7 @@ export class TestObjectProvider implements ITestObjectProvider {
 	}
 
 	public async ensureSynchronized(timeoutDuration?: number): Promise<void> {
-		return this._loaderContainerTracker.ensureSynchronizedWithTimeout
-			? this._loaderContainerTracker.ensureSynchronizedWithTimeout(timeoutDuration)
-			: this._loaderContainerTracker.ensureSynchronized();
+		return this._loaderContainerTracker.ensureSynchronized();
 	}
 
 	public async waitContainerToCatchUp(container: IContainer) {

package/src/timeoutUtils.ts

@@ -3,7 +3,6 @@
  * Licensed under the MIT License.
  */
 
-import { Container } from "@fluidframework/container-loader";
 import { assert, Deferred } from "@fluidframework/common-utils";
 
 // @deprecated this value is no longer used
@@ -133,12 +132,6 @@ export async function timeoutAwait<T = void>(
 	return Promise.race([promise, timeoutPromise<T>(() => {}, timeoutOptions)]);
 }
 
-export async function ensureContainerConnected(container: Container): Promise<void> {
-	if (!container.connected) {
-		return timeoutPromise((resolve) => container.once("connected", () => resolve()));
-	}
-}
-
 // Create a promise based on the timeout options
 async function getTimeoutPromise<T = void>(
 	executor: (