@fluidframework/test-utils 2.0.0-internal.2.3.1 → 2.0.0-internal.3.0.0

package/src/TestSummaryUtils.ts

@@ -6,7 +6,6 @@
 import { ContainerRuntimeFactoryWithDefaultDataStore } from "@fluidframework/aqueduct";
 import { assert } from "@fluidframework/common-utils";
 import { IContainer, IHostLoader, LoaderHeader } from "@fluidframework/container-definitions";
-import { ConnectionState } from "@fluidframework/container-loader";
 import {
     IGCRuntimeOptions,
     ISummarizer,
@@ -24,6 +23,8 @@ import { IConfigProviderBase } from "@fluidframework/telemetry-utils";
 import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
 import { ITestContainerConfig, ITestObjectProvider } from "./testObjectProvider";
 import { mockConfigProvider } from "./TestConfigs";
+import { waitForContainerConnection } from "./containerUtils";
+import { timeoutAwait } from "./timeoutUtils";
 
 const summarizerClientType = "summarizer";
 
@@ -65,7 +66,6 @@ const defaultSummaryOptions: ISummaryRuntimeOptions = {
         maxAckWaitTime: 10000,
         maxOpsSinceLastSummary: 7000,
         initialSummarizerDelayMs: 0,
-        summarizerClientElection: false,
     },
 };
 
@@ -142,16 +142,16 @@ export async function createSummarizerWithContainer(
 export async function summarizeNow(summarizer: ISummarizer, reason: string = "end-to-end test") {
     const result = summarizer.summarizeOnDemand({ reason });
 
-    const submitResult = await result.summarySubmitted;
+    const submitResult = await timeoutAwait(result.summarySubmitted);
     assert(submitResult.success, "on-demand summary should submit");
     assert(submitResult.data.stage === "submit",
         "on-demand summary submitted data stage should be submit");
     assert(submitResult.data.summaryTree !== undefined, "summary tree should exist");
 
-    const broadcastResult = await result.summaryOpBroadcasted;
+    const broadcastResult = await timeoutAwait(result.summaryOpBroadcasted);
     assert(broadcastResult.success, "summary op should be broadcast");
 
-    const ackNackResult = await result.receivedSummaryAckOrNack;
+    const ackNackResult = await timeoutAwait(result.receivedSummaryAckOrNack);
     assert(ackNackResult.success, "summary op should be acked");
 
     await new Promise((resolve) => process.nextTick(resolve));
@@ -162,9 +162,3 @@ export async function summarizeNow(summarizer: ISummarizer, reason: string = "en
         summaryRefSeq: submitResult.data.referenceSequenceNumber,
     };
 }
-
-export async function waitForContainerConnection(container: IContainer): Promise<void> {
-    if (container.connectionState !== ConnectionState.Connected) {
-        return new Promise((resolve) => container.once("connected", () => resolve()));
-    }
-}

package/src/containerUtils.ts

@@ -0,0 +1,59 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IContainer } from "@fluidframework/container-definitions";
+import { ConnectionState, Container } from "@fluidframework/container-loader";
+import { PromiseExecutor, timeoutPromise, TimeoutWithError } from "./timeoutUtils";
+
+/**
+ * Waits for the specified container to emit a 'connected' event.
+ *
+ * @deprecated Use waitForContainerConnection instead.
+ * Note that an upcoming release will change the default parameters on that function to:
+ * - failOnContainerClose = true
+ * - timeoutOptions.durationMs = 1s
+ */
+export async function ensureContainerConnected(container: Container): Promise<void> {
+    if (!container.connected) {
+        return timeoutPromise((resolve) => container.once("connected", () => resolve()));
+    }
+}
+
+/**
+ * Utility function to wait for the specified Container to be in Connected state.
+ * If the Container is already connected, the Promise returns immediately; otherwise it resolves when the Container emits
+ * its 'connected' event.
+ * If failOnContainerClose === true, the returned Promise will be rejected if the container emits a 'closed' event
+ * before a 'connected' event.
+ * @param container - The container to wait for.
+ * @param failOnContainerClose - If true, the returned Promise will be rejected if the container emits a 'closed' event
+ * before a 'connected' event.
+ * Defaults to false (but this will change in an upcoming version).
+ * @param timeoutOptions - Options related to the behavior of the timeout.
+ * If not provided, no timeout will be applied and the promise will wait indefinitely for the Container to emit its
+ * 'connected' (or 'closed, if failOnContainerClose === true) event.
+ * @returns A Promise that resolves when the specified container emits a 'connected' event (or immediately if the
+ * Container is already connected).
+ * If failOnContainerClose === true and the container emits a 'closed' event before a 'connected' event, the Promise
+ * is rejected with the error from the 'closed' event, if any.
+ * If timeoutOptions is provided, the Promise will reject if the container hasn't emmited a relevant event before
+ * timeoutOptions.durationMs (which defaults to 250ms if left undefined).
+ */
+export async function waitForContainerConnection(
+    container: IContainer,
+    failOnContainerClose: boolean = false,
+    timeoutOptions?: TimeoutWithError): Promise<void> {
+    if (container.connectionState !== ConnectionState.Connected) {
+
+        const executor: PromiseExecutor = (resolve, reject) => {
+            container.once("connected", () => resolve())
+            if (failOnContainerClose) {
+                container.once("closed", (error) =>  reject(error));
+            }
+        };
+
+        return timeoutOptions === undefined ? new Promise(executor) : timeoutPromise(executor, timeoutOptions);
+    }
+}

package/src/index.ts

@@ -27,13 +27,15 @@ export {
     createSummarizerFromFactory,
     createSummarizerWithContainer,
     summarizeNow,
-    waitForContainerConnection,
 } from "./TestSummaryUtils";
 export {
     defaultTimeoutDurationMs,
-    ensureContainerConnected,
     timeoutAwait,
     timeoutPromise,
     TimeoutWithError,
     TimeoutWithValue,
 } from "./timeoutUtils";
+export {
+    ensureContainerConnected,
+    waitForContainerConnection,
+} from "./containerUtils";

package/src/loaderContainerTracker.ts

@@ -2,8 +2,6 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-/* eslint-disable @typescript-eslint/strict-boolean-expressions */
-
 import { assert } from "@fluidframework/common-utils";
 import { IContainer, IDeltaQueue, IHostLoader } from "@fluidframework/container-definitions";
 import { Container } from "@fluidframework/container-loader";
@@ -16,9 +14,6 @@ import { timeoutAwait, timeoutPromise } from "./timeoutUtils";
 const debugOp = debug.extend("ops");
 const debugWait = debug.extend("wait");
 
-// set the maximum timeout value as 5 mins
-const defaultMaxTimeout = 5 * 6000;
-
 interface ContainerRecord {
     // A short number for debug output
     index: number;
@@ -187,7 +182,6 @@ export class LoaderContainerTracker implements IOpProcessingController {
      * - Trailing NoOp is tracked and don't count as pending ops.
      */
     private async processSynchronized(timeoutDuration: number | undefined, ...containers: IContainer[]) {
-        const start = Date.now();
         const resumed = this.resumeProcessing(...containers);
 
         let waitingSequenceNumberSynchronized = false;
@@ -214,14 +208,12 @@ export class LoaderContainerTracker implements IOpProcessingController {
                         waitingSequenceNumberSynchronized = true;
                         debugWait("Waiting for sequence number synchronized");
                         await timeoutAwait(this.waitForAnyInboundOps(containersToApply), {
-                            durationMs: timeoutDuration ? timeoutDuration - (Date.now() - start) : defaultMaxTimeout,
                             errorMsg: "Timeout on waiting for sequence number synchronized",
                         });
                     }
                 } else {
                     waitingSequenceNumberSynchronized = false;
                     await timeoutAwait(this.waitForPendingClients(pendingClients), {
-                            durationMs: timeoutDuration ? timeoutDuration - (Date.now() - start) : defaultMaxTimeout,
                         errorMsg: "Timeout on waiting for pending join or leave op",
                     });
                 }
@@ -230,12 +222,10 @@ export class LoaderContainerTracker implements IOpProcessingController {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 debugWait(`Waiting container to be saved ${dirtyContainers.map((c) => this.containers.get(c)!.index)}`);
                 waitingSequenceNumberSynchronized = false;
-                const remainedDuration = timeoutDuration ? timeoutDuration - (Date.now() - start) : defaultMaxTimeout;
                 await Promise.all(dirtyContainers.map(async (c) => Promise.race(
                     [timeoutPromise(
                         (resolve) => c.once("saved", () => resolve()),
                         {
-                            durationMs: remainedDuration,
                             errorMsg: "Timeout on waiting a container to be saved",
                         },
                     ),
@@ -252,7 +242,6 @@ export class LoaderContainerTracker implements IOpProcessingController {
         // don't call pause if resumed is empty and pause everything, which is not what we want
         if (resumed.length !== 0) {
             await timeoutAwait(this.pauseProcessing(...resumed), {
-                durationMs: timeoutDuration ? timeoutDuration - (Date.now() - start) : defaultMaxTimeout,
                 errorMsg: "Timeout on waiting for pausing all resumed containers",
             });
         }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/test-utils";
-export const pkgVersion = "2.0.0-internal.2.3.1";
+export const pkgVersion = "2.0.0-internal.3.0.0";

package/src/testContainerRuntimeFactory.ts

@@ -67,7 +67,7 @@ export const createTestContainerRuntimeFactory = (containerRuntimeCtor: typeof C
                     ...this.requestHandlers,
                 ),
                 this.runtimeOptions,
-                undefined, // containerScope
+                context.scope,
                 existing,
             );
 

package/src/testObjectProvider.ts

@@ -88,6 +88,9 @@ export interface ITestContainerConfig {
     /** Container runtime options for the container instance */
     runtimeOptions?: IContainerRuntimeOptions;
 
+    /** Whether this runtime should be instantiated using a mixed-in attributor class */
+    enableAttribution?: boolean;
+
     /** Loader options for the loader used to create containers */
     loaderProps?: Partial<ILoaderProps>;
 }
@@ -146,7 +149,7 @@ export class EventAndErrorTrackingLogger extends TelemetryLogger {
     private readonly expectedEvents: ({ index: number; event: ITelemetryGenericEvent | undefined; } | undefined)[] = [];
     private readonly unexpectedErrors: ITelemetryBaseEvent[] = [];
 
-    public registerExpectedEvent(... orderedExpectedEvents: ITelemetryGenericEvent[]) {
+    public registerExpectedEvent(...orderedExpectedEvents: ITelemetryGenericEvent[]) {
         if (this.expectedEvents.length !== 0) {
             // we don't have to error here. just no reason not to. given the events must be
             // ordered it could be tricky to figure out problems around multiple registrations.
@@ -154,7 +157,7 @@ export class EventAndErrorTrackingLogger extends TelemetryLogger {
                 "Expected events already registered.\n"
                 + "Call reportAndClearTrackedEvents to clear them before registering more");
         }
-        this.expectedEvents.push(... orderedExpectedEvents.map((event, index) => ({ index, event })));
+        this.expectedEvents.push(...orderedExpectedEvents.map((event, index) => ({ index, event })));
     }
 
     send(event: ITelemetryBaseEvent): void {
@@ -229,14 +232,14 @@ export class TestObjectProvider implements ITestObjectProvider {
         if (this._logger === undefined) {
             this._logger = new EventAndErrorTrackingLogger(
                 ChildLogger.create(getTestLogger?.(), undefined,
-                {
-                    all: {
-                        driverType: this.driver.type,
-                        driverEndpointName: this.driver.endpointName,
-                        driverTenantName: this.driver.tenantName,
-                        driverUserIndex: this.driver.userIndex,
-                    },
-                }));
+                    {
+                        all: {
+                            driverType: this.driver.type,
+                            driverEndpointName: this.driver.endpointName,
+                            driverTenantName: this.driver.tenantName,
+                            driverUserIndex: this.driver.userIndex,
+                        },
+                    }));
         }
         return this._logger;
     }
@@ -290,7 +293,7 @@ export class TestObjectProvider implements ITestObjectProvider {
         }
 
         const loader = new this.LoaderConstructor({
-            ... loaderProps,
+            ...loaderProps,
             logger: multiSinkLogger,
             codeLoader: loaderProps?.codeLoader ?? new LocalCodeLoader(packageEntries),
             urlResolver: loaderProps?.urlResolver ?? this.urlResolver,
@@ -404,10 +407,9 @@ export class TestObjectProvider implements ITestObjectProvider {
     }
 
     public async ensureSynchronized(timeoutDuration?: number): Promise<void> {
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        return !timeoutDuration
-            ? this._loaderContainerTracker.ensureSynchronized()
-            : this._loaderContainerTracker.ensureSynchronizedWithTimeout?.(timeoutDuration);
+        return this._loaderContainerTracker.ensureSynchronizedWithTimeout
+            ? this._loaderContainerTracker.ensureSynchronizedWithTimeout(timeoutDuration)
+            : this._loaderContainerTracker.ensureSynchronized();
     }
 
     public async waitContainerToCatchUp(container: IContainer) {

package/src/timeoutUtils.ts

@@ -4,20 +4,123 @@
  */
 
 import { Container } from "@fluidframework/container-loader";
+import { assert, Deferred } from "@fluidframework/common-utils";
 
+// @deprecated this value is no longer used
 export const defaultTimeoutDurationMs = 250;
 
+// TestTimeout class manage tracking of test timeout. It create a timer when timeout is in effect,
+// and provide a promise that will be reject before the test timeout happen with a `timeBuffer` of 15 ms.
+// Once rejected, a new TestTimeout object will be create for the timeout.
+
+const timeBuffer = 15; // leave 15 ms leeway for finish processing
+
+class TestTimeout {
+    private timeout: number = 0;
+    private timer: NodeJS.Timeout | undefined;
+    private readonly deferred: Deferred<void>;
+    private rejected = false;
+
+    private static instance: TestTimeout = new TestTimeout();
+    public static reset(runnable: Mocha.Runnable) {
+        TestTimeout.clear();
+        TestTimeout.instance.resetTimer(runnable);
+    }
+
+    public static clear() {
+        if (TestTimeout.instance.rejected) {
+            TestTimeout.instance = new TestTimeout();
+        } else {
+            TestTimeout.instance.clearTimer();
+        }
+    }
+
+    public static getInstance() {
+        return TestTimeout.instance;
+    }
+
+    public async getPromise() {
+        return this.deferred.promise;
+    }
+
+    public getTimeout() {
+        return this.timeout;
+    }
+
+    private constructor() {
+        this.deferred = new Deferred();
+        // Ignore rejection for timeout promise if no one is waiting for it.
+        this.deferred.promise.catch(() => { });
+    }
+
+    private resetTimer(runnable: Mocha.Runnable) {
+        assert(!this.timer, "clearTimer should have been called before reset");
+        assert(!this.deferred.isCompleted, "can't reset a completed TestTimeout");
+
+        // Check the test timeout setting
+        const timeout = runnable.timeout();
+        if (!(Number.isFinite(timeout) && timeout > 0)) { return; }
+
+        // subtract a buffer
+        this.timeout = Math.max(timeout - timeBuffer, 1);
+
+        // Set up timer to reject near the test timeout.
+        this.timer = setTimeout(() => {
+            this.deferred.reject(this);
+            this.rejected = true;
+        }, this.timeout);
+    }
+    private clearTimer() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+    }
+}
+
+// only register if we are running with mocha-test-setup loaded
+if (globalThis.getMochaModule !== undefined) {
+    // patching resetTimeout and clearTimeout on the runnable object
+    // so we can track when test timeout are enforced
+    const mochaModule = globalThis.getMochaModule() as typeof Mocha;
+    const runnablePrototype = mochaModule.Runnable.prototype;
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const oldResetTimeoutFunc = runnablePrototype.resetTimeout;
+    runnablePrototype.resetTimeout = function(this: Mocha.Runnable) {
+        oldResetTimeoutFunc.call(this);
+        TestTimeout.reset(this);
+    };
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const oldClearTimeoutFunc = runnablePrototype.clearTimeout;
+    runnablePrototype.clearTimeout = function(this: Mocha.Runnable) {
+        TestTimeout.clear();
+        oldClearTimeoutFunc.call(this);
+    };
+}
+
 export interface TimeoutWithError {
+    /**
+     * Timeout duration in milliseconds, if it is great than 0 and not Infinity
+     * If it is undefined, then it will use test timeout if we are in side the test function
+     * Otherwise, there is no timeout
+     */
     durationMs?: number;
     reject?: true;
     errorMsg?: string;
 }
 export interface TimeoutWithValue<T = void> {
+    /**
+     * Timeout duration in milliseconds, if it is great than 0 and not Infinity
+     * If it is undefined, then it will use test timeout if we are in side the test function
+     * Otherwise, there is no timeout
+     */
     durationMs?: number;
     reject: false;
     value: T;
 }
 
+export type PromiseExecutor<T = void> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void;
+
 export async function timeoutAwait<T = void>(
     promise: PromiseLike<T>,
     timeoutOptions: TimeoutWithError | TimeoutWithValue<T> = {},
@@ -31,23 +134,26 @@ export async function ensureContainerConnected(container: Container): Promise<vo
     }
 }
 
-export async function timeoutPromise<T = void>(
+// Create a promise based on the timeout options
+async function getTimeoutPromise<T = void>(
     executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void,
-    timeoutOptions: TimeoutWithError | TimeoutWithValue<T> = {},
-): Promise<T> {
-    const timeout =
-        timeoutOptions.durationMs !== undefined
-        && Number.isFinite(timeoutOptions.durationMs)
-        && timeoutOptions.durationMs > 0
-            ? timeoutOptions.durationMs : defaultTimeoutDurationMs;
-    // create the timeout error outside the async task, so its callstack includes
-    // the original call site, this makes it easier to debug
-    const err = timeoutOptions.reject === false
-        ? undefined
-        : new Error(`${timeoutOptions.errorMsg ?? "Timed out"}(${timeout}ms)`);
+    timeoutOptions: TimeoutWithError | TimeoutWithValue<T>,
+    err: Error | undefined,
+) {
+    const timeout = timeoutOptions.durationMs ?? 0;
+    if (timeout <= 0 || !Number.isFinite(timeout)) {
+        return new Promise(executor);
+    }
+
     return new Promise<T>((resolve, reject) => {
+        const timeoutRejections = () => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const errorObject = err!;
+            errorObject.message = `${errorObject.message} (${timeout}ms)`;
+            reject(err);
+        };
         const timer = setTimeout(
-            () => timeoutOptions.reject === false ? resolve(timeoutOptions.value) : reject(err),
+            () => timeoutOptions.reject === false ? resolve(timeoutOptions.value) : timeoutRejections(),
             timeout);
 
         executor(
@@ -61,3 +167,34 @@ export async function timeoutPromise<T = void>(
             });
     });
 }
+
+// Create a promise based on test timeout and the timeout options
+export async function timeoutPromise<T = void>(
+    executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void,
+    timeoutOptions: TimeoutWithError | TimeoutWithValue<T> = {},
+): Promise<T> {
+    // create the timeout error outside the async task, so its callstack includes
+    // the original call site, this makes it easier to debug
+    const err = timeoutOptions.reject === false
+        ? undefined
+        : new Error(timeoutOptions.errorMsg ?? "Timed out");
+    const executorPromise = getTimeoutPromise(executor, timeoutOptions, err);
+
+    const currentTestTimeout = TestTimeout.getInstance();
+    if (currentTestTimeout === undefined) { return executorPromise; }
+
+    return Promise.race([executorPromise, currentTestTimeout.getPromise()]).catch((e) => {
+        if (e === currentTestTimeout) {
+            if (timeoutOptions.reject !== false) {
+                // If the rejection is because of the timeout then
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const errorObject = err!;
+                errorObject.message =
+                    `${timeoutOptions.errorMsg ?? "Test timed out"} (${currentTestTimeout.getTimeout()}ms)`;
+                throw errorObject;
+            }
+            return timeoutOptions.value;
+        }
+        throw e;
+    }) as Promise<T>;
+}

package/tsconfig.json

@@ -6,8 +6,11 @@
     "compilerOptions": {
         "rootDir": "./src",
         "outDir": "./dist",
-        "types": ["node"],
-        "composite": true
+        "composite": true,
+        "types": [
+            "mocha",
+            "node"
+        ]
     },
     "include": [
         "src/**/*"