@fluidframework/test-utils 1.3.0 → 2.0.0-dev.1.4.5.105745

package/src/loaderContainerTracker.ts

@@ -2,17 +2,23 @@
  * 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";
+import { canBeCoalescedByService } from "@fluidframework/driver-utils";
 import { IDocumentMessage, ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
 import { debug } from "./debug";
 import { IOpProcessingController } from "./testObjectProvider";
+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;
@@ -91,7 +97,7 @@ export class LoaderContainerTracker implements IOpProcessingController {
     private trackTrailingNoOps(container: IContainer, record: ContainerRecord) {
         container.deltaManager.outbound.on("op", (messages) => {
             for (const msg of messages) {
-                if (msg.type === MessageType.NoOp) {
+                if (canBeCoalescedByService(msg)) {
                     // Track the NoOp that was sent.
                     if (record.trailingNoOps === 0) {
                         // record the starting sequence number of the trailing no ops if we haven't been tracking yet.
@@ -107,7 +113,7 @@ export class LoaderContainerTracker implements IOpProcessingController {
 
         container.deltaManager.inbound.on("push", (message) => {
             // Received the no op back, update the record if we are tracking
-            if (message.type === MessageType.NoOp
+            if (canBeCoalescedByService(message)
                 && message.clientId === (container as Container).clientId
                 && record.trailingNoOps !== 0
                 && record.startTrailingNoOps <= message.clientSequenceNumber
@@ -147,18 +153,41 @@ export class LoaderContainerTracker implements IOpProcessingController {
         // REVIEW: do we need to unpatch the loaders?
     }
 
+    /**
+     * Ensure all tracked containers are synchronized
+     */
+    public async ensureSynchronized(...containers: IContainer[]): Promise<void> {
+        await this.processSynchronized(undefined, ...containers);
+    }
+
+    /**
+     * Ensure all tracked containers are synchronized with a time limit
+     */
+    public async ensureSynchronizedWithTimeout?(timeoutDuration: number | undefined, ...containers: IContainer[]) {
+        await this.processSynchronized(timeoutDuration, ...containers);
+    }
+
     /**
      * Make sure all the tracked containers are synchronized.
-     * - No isDirty (non-readonly) containers
-     * - No extra clientId in quorum of any container that is not tracked and still opened.
-     *      - i.e. no pending Join/Leave message.
-     * - No unresolved proposal (minSeqNum \>= lastProposalSeqNum)
-     * - lastSequenceNumber of all container is the same
-     * - clientSequenceNumberObserved is the same as clientSequenceNumber sent
-     *      - this overlaps with !isDirty, but include task scheduler ops.
-     *      - Trailing NoOp is tracked and don't count as pending ops.
+     *
+     * No isDirty (non-readonly) containers
+     *
+     * No extra clientId in quorum of any container that is not tracked and still opened.
+     *
+     * - i.e. no pending Join/Leave message.
+     *
+     * No unresolved proposal (minSeqNum \>= lastProposalSeqNum)
+     *
+     * lastSequenceNumber of all container is the same
+     *
+     * clientSequenceNumberObserved is the same as clientSequenceNumber sent
+     *
+     * - this overlaps with !isDirty, but include task scheduler ops.
+     *
+     * - Trailing NoOp is tracked and don't count as pending ops.
      */
-    public async ensureSynchronized(...containers: IContainer[]) {
+    private async processSynchronized(timeoutDuration: number | undefined, ...containers: IContainer[]) {
+        const start = Date.now();
         const resumed = this.resumeProcessing(...containers);
 
         let waitingSequenceNumberSynchronized = false;
@@ -184,20 +213,34 @@ export class LoaderContainerTracker implements IOpProcessingController {
                         // Only write it out once
                         waitingSequenceNumberSynchronized = true;
                         debugWait("Waiting for sequence number synchronized");
-                        await this.waitForAnyInboundOps(containersToApply);
+                        await timeoutAwait(this.waitForAnyInboundOps(containersToApply), {
+                            durationMs: timeoutDuration ? timeoutDuration - (Date.now() - start) : defaultMaxTimeout,
+                            errorMsg: "Timeout on waiting for sequence number synchronized",
+                        });
                     }
                 } else {
                     waitingSequenceNumberSynchronized = false;
-                    await this.waitForPendingClients(pendingClients);
+                    await timeoutAwait(this.waitForPendingClients(pendingClients), {
+                            durationMs: timeoutDuration ? timeoutDuration - (Date.now() - start) : defaultMaxTimeout,
+                        errorMsg: "Timeout on waiting for pending join or leave op",
+                    });
                 }
             } else {
                 // Wait for all the containers to be saved
                 // 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(
-                    [new Promise((resolve) => c.once("saved", resolve)),
-                    new Promise((resolve) => c.once("closed", resolve))],
+                    [timeoutPromise(
+                        (resolve) => c.once("saved", () => resolve()),
+                        {
+                            durationMs: remainedDuration,
+                            errorMsg: "Timeout on waiting a container to be saved",
+                        },
+                    ),
+                    new Promise((resolve) => c.once("closed", resolve)),
+                    ],
                 )));
             }
 
@@ -208,7 +251,10 @@ export class LoaderContainerTracker implements IOpProcessingController {
         // Pause all container that was resumed
         // don't call pause if resumed is empty and pause everything, which is not what we want
         if (resumed.length !== 0) {
-            await this.pauseProcessing(...resumed);
+            await timeoutAwait(this.pauseProcessing(...resumed), {
+                durationMs: timeoutDuration ? timeoutDuration - (Date.now() - start) : defaultMaxTimeout,
+                errorMsg: "Timeout on waiting for pausing all resumed containers",
+            });
         }
 
         debugWait("Synchronized");
@@ -454,13 +500,13 @@ export class LoaderContainerTracker implements IOpProcessingController {
     private setupInOutTracker(container: IContainer, inflightTracker: Map<IContainer, number>) {
         const outHandler = (messages: IDocumentMessage[]) => {
             for (const message of messages) {
-                if (message.type !== MessageType.NoOp) {
+                if (!canBeCoalescedByService(message)) {
                     inflightTracker.set(container, message.clientSequenceNumber);
                 }
             }
         };
         const inHandler = (message: ISequencedDocumentMessage) => {
-            if (message.type !== MessageType.NoOp
+            if (!canBeCoalescedByService(message)
                 && message.clientId === (container as Container).clientId
                 && inflightTracker.get(container) === message.clientSequenceNumber) {
                 inflightTracker.delete(container);

package/src/localCodeLoader.ts

@@ -43,14 +43,10 @@ export class LocalCodeLoader implements ICodeDetailsLoader {
             // Store the entry point against a unique id in the fluidPackageCache.
             // For code details containing a package name, use the package name as the id.
             // For code details containing a Fluid package, create a unique id from the package name and version.
-            let pkgId: string;
-
             const source = entry[0];
-            if (typeof source.package === "string") {
-                pkgId = source.package;
-            } else {
-                pkgId = `${source.package.name}@${source.package.version}`;
-            }
+            const pkgId = typeof source.package === "string"
+                ? source.package
+                : `${source.package.name}@${source.package.version}`;
             let fluidModule = entry[1] as IFluidModule;
             if (fluidModule?.fluidExport === undefined) {
                 const maybeExport = fluidModule as SupportedExportInterfaces;
@@ -98,13 +94,9 @@ export class LocalCodeLoader implements ICodeDetailsLoader {
         // Get the entry point for from the fluidPackageCache for the given code details.
         // For code details containing a package name, use the package name as the id.
         // For code details containing a Fluid package, create a unique id from the package name and version.
-        let pkdId: string;
-
-        if (typeof source.package === "string") {
-            pkdId = source.package;
-        } else {
-            pkdId = `${source.package.name}@${source.package.version}`;
-        }
+        const pkdId = typeof source.package === "string"
+            ? source.package
+            : `${source.package.name}@${source.package.version}`;
 
         const entryPoint = this.fluidPackageCache.get(pkdId);
         if (entryPoint === undefined) {

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/test-utils";
-export const pkgVersion = "1.3.0";
+export const pkgVersion = "2.0.0-dev.1.4.5.105745";

package/src/testFluidObject.ts

@@ -109,17 +109,24 @@ export type ChannelFactoryRegistry = Iterable<[string | undefined, IChannelFacto
  * with the object factories in the entry list. All the entries with an id other than undefined are passed to the
  * Fluid object so that it can create a shared object for each.
  *
- * For example, the following will create a Fluid object that creates and loads a SharedString and SharedDirectory. It
- * will add SparseMatrix to the data store's factory so that it can be created later.
- *      new TestFluidObjectFactory([
- *          [ "sharedString", SharedString.getFactory() ],
- *          [ "sharedDirectory", SharedDirectory.getFactory() ],
-*          [ undefined, SparseMatrix.getFactory() ],
- *      ]);
+ * @example
+ * The following will create a Fluid object that creates and loads a SharedString and SharedDirectory.
+ * It will add SparseMatrix to the data store's factory so that it can be created later.
+ *
+ * ```typescript
+ * new TestFluidObjectFactory([
+ *  [ "sharedString", SharedString.getFactory() ],
+ *  [ "sharedDirectory", SharedDirectory.getFactory() ],
+ *  [ undefined, SparseMatrix.getFactory() ],
+ * ]);
+ * ```
  *
  * The SharedString and SharedDirectory can be retrieved via getSharedObject() on the TestFluidObject as follows:
- *      sharedString = testFluidObject.getSharedObject<SharedString>("sharedString");
- *      sharedDir = testFluidObject.getSharedObject<SharedDirectory>("sharedDirectory");
+ *
+ * ```typescript
+ * sharedString = testFluidObject.getSharedObject<SharedString>("sharedString");
+ * sharedDir = testFluidObject.getSharedObject<SharedDirectory>("sharedDirectory");
+ * ```
  */
 export class TestFluidObjectFactory implements IFluidDataStoreFactory {
     public get IFluidDataStoreFactory() { return this; }

package/src/testObjectProvider.ts

@@ -66,7 +66,7 @@ export interface ITestObjectProvider {
     defaultCodeDetails: IFluidCodeDetails;
     opProcessingController: IOpProcessingController;
 
-    ensureSynchronized(): Promise<void>;
+    ensureSynchronized(timeoutDuration?: number): Promise<void>;
     reset(): void;
 
     documentId: string;
@@ -231,6 +231,10 @@ export class TestObjectProvider implements ITestObjectProvider {
         return this._logger;
     }
 
+    set logger(logger: EventAndErrorTrackingLogger) {
+        this._logger = logger;
+    }
+
     get documentServiceFactory() {
         if (!this._documentServiceFactory) {
             this._documentServiceFactory = this.driver.createDocumentServiceFactory();
@@ -389,8 +393,11 @@ export class TestObjectProvider implements ITestObjectProvider {
         this._documentCreated = false;
     }
 
-    public async ensureSynchronized() {
-        return this._loaderContainerTracker.ensureSynchronized();
+    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);
     }
 
     public async waitContainerToCatchUp(container: IContainer) {

package/src/timeoutUtils.ts

@@ -3,6 +3,8 @@
  * Licensed under the MIT License.
  */
 
+import { Container } from "@fluidframework/container-loader";
+
 export const defaultTimeoutDurationMs = 250;
 
 export interface TimeoutWithError {
@@ -23,6 +25,12 @@ 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()));
+    }
+}
+
 export async function timeoutPromise<T = void>(
     executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void,
     timeoutOptions: TimeoutWithError | TimeoutWithValue<T> = {},
@@ -32,7 +40,7 @@ export async function timeoutPromise<T = void>(
         && Number.isFinite(timeoutOptions.durationMs)
         && timeoutOptions.durationMs > 0
             ? timeoutOptions.durationMs : defaultTimeoutDurationMs;
-    // create the timeout error outside the async task, so it's callstack includes
+    // 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