@fluidframework/test-utils 2.0.0-internal.3.0.1 → 2.0.0-internal.3.1.0

package/src/localCodeLoader.ts

@@ -6,24 +6,28 @@
 import assert from "assert";
 import { ContainerRuntimeFactoryWithDefaultDataStore } from "@fluidframework/aqueduct";
 import {
-    IProvideRuntimeFactory,
-    IFluidModule,
-    IProvideFluidCodeDetailsComparer,
-    IFluidCodeDetails,
-    ICodeDetailsLoader,
-    IFluidModuleWithDetails,
+	IProvideRuntimeFactory,
+	IFluidModule,
+	IProvideFluidCodeDetailsComparer,
+	IFluidCodeDetails,
+	ICodeDetailsLoader,
+	IFluidModuleWithDetails,
 } from "@fluidframework/container-definitions";
 import { IRequest } from "@fluidframework/core-interfaces";
-import { IContainerRuntimeBase, IProvideFluidDataStoreFactory,
-    IProvideFluidDataStoreRegistry } from "@fluidframework/runtime-definitions";
+import {
+	IContainerRuntimeBase,
+	IProvideFluidDataStoreFactory,
+	IProvideFluidDataStoreRegistry,
+} from "@fluidframework/runtime-definitions";
 import { createDataStoreFactory } from "@fluidframework/runtime-utils";
 import { IContainerRuntimeOptions } from "@fluidframework/container-runtime";
 
 export type SupportedExportInterfaces = Partial<
-    IProvideRuntimeFactory &
-    IProvideFluidDataStoreFactory &
-    IProvideFluidDataStoreRegistry &
-    IProvideFluidCodeDetailsComparer>;
+	IProvideRuntimeFactory &
+		IProvideFluidDataStoreFactory &
+		IProvideFluidDataStoreRegistry &
+		IProvideFluidCodeDetailsComparer
+>;
 
 // Represents the entry point for a Fluid container.
 export type fluidEntryPoint = SupportedExportInterfaces | IFluidModule;
@@ -33,75 +37,79 @@ export type fluidEntryPoint = SupportedExportInterfaces | IFluidModule;
  * On load, it retrieves the entry point matching the package name in the given code details.
  */
 export class LocalCodeLoader implements ICodeDetailsLoader {
-    private readonly fluidPackageCache = new Map<string, IFluidModuleWithDetails>();
+	private readonly fluidPackageCache = new Map<string, IFluidModuleWithDetails>();
 
-    constructor(
-        packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>,
-        runtimeOptions?: IContainerRuntimeOptions,
-    ) {
-        for (const entry of packageEntries) {
-            // 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.
-            const source = entry[0];
-            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;
+	constructor(
+		packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>,
+		runtimeOptions?: IContainerRuntimeOptions,
+	) {
+		for (const entry of packageEntries) {
+			// 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.
+			const source = entry[0];
+			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;
 
-                if (maybeExport.IRuntimeFactory !== undefined) {
-                    fluidModule = { fluidExport: maybeExport };
-                } else {
-                    assert(maybeExport.IFluidDataStoreFactory !== undefined);
-                    const defaultFactory = createDataStoreFactory("default", maybeExport.IFluidDataStoreFactory);
-                    const innerRequestHandler = async (request: IRequest, runtime: IContainerRuntimeBase) =>
-                        runtime.IFluidHandleContext.resolveHandle(request);
-                    fluidModule = {
-                        fluidExport: {
-                            ... maybeExport,
-                            IRuntimeFactory:
-                                new ContainerRuntimeFactoryWithDefaultDataStore(
-                                    defaultFactory,
-                                    [[defaultFactory.type, Promise.resolve(defaultFactory)]],
-                                    undefined,
-                                    [innerRequestHandler],
-                                    runtimeOptions,
-                                ),
-                        },
-                    };
-                }
-            }
+				if (maybeExport.IRuntimeFactory !== undefined) {
+					fluidModule = { fluidExport: maybeExport };
+				} else {
+					assert(maybeExport.IFluidDataStoreFactory !== undefined);
+					const defaultFactory = createDataStoreFactory(
+						"default",
+						maybeExport.IFluidDataStoreFactory,
+					);
+					const innerRequestHandler = async (
+						request: IRequest,
+						runtime: IContainerRuntimeBase,
+					) => runtime.IFluidHandleContext.resolveHandle(request);
+					fluidModule = {
+						fluidExport: {
+							...maybeExport,
+							IRuntimeFactory: new ContainerRuntimeFactoryWithDefaultDataStore(
+								defaultFactory,
+								[[defaultFactory.type, Promise.resolve(defaultFactory)]],
+								undefined,
+								[innerRequestHandler],
+								runtimeOptions,
+							),
+						},
+					};
+				}
+			}
 
-            const runtimeFactory = {
-                module: fluidModule,
-                details: source,
-            };
+			const runtimeFactory = {
+				module: fluidModule,
+				details: source,
+			};
 
-            this.fluidPackageCache.set(pkgId, runtimeFactory);
-        }
-    }
+			this.fluidPackageCache.set(pkgId, runtimeFactory);
+		}
+	}
 
-    /**
-     * It finds the entry point for the package name in the given source and return it
-     * as a Fluid module.
-     * @param source - Details of where to find chaincode
-     */
-    public async load(
-        source: IFluidCodeDetails,
-    ): Promise<IFluidModuleWithDetails> {
-        // 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.
-        const pkdId = typeof source.package === "string"
-            ? source.package
-            : `${source.package.name}@${source.package.version}`;
+	/**
+	 * It finds the entry point for the package name in the given source and return it
+	 * as a Fluid module.
+	 * @param source - Details of where to find chaincode
+	 */
+	public async load(source: IFluidCodeDetails): Promise<IFluidModuleWithDetails> {
+		// 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.
+		const pkdId =
+			typeof source.package === "string"
+				? source.package
+				: `${source.package.name}@${source.package.version}`;
 
-        const entryPoint = this.fluidPackageCache.get(pkdId);
-        if (entryPoint === undefined) {
-            throw new Error(`Cannot find package ${pkdId}`);
-        }
-        return entryPoint;
-    }
+		const entryPoint = this.fluidPackageCache.get(pkdId);
+		if (entryPoint === undefined) {
+			throw new Error(`Cannot find package ${pkdId}`);
+		}
+		return entryPoint;
+	}
 }

package/src/localLoader.ts

@@ -4,11 +4,11 @@
  */
 
 import {
-    ICodeDetailsLoader,
-    IContainer,
-    IHostLoader,
-    ILoaderOptions,
-    IFluidCodeDetails,
+	ICodeDetailsLoader,
+	IContainer,
+	IHostLoader,
+	ILoaderOptions,
+	IFluidCodeDetails,
 } from "@fluidframework/container-definitions";
 import { Loader } from "@fluidframework/container-loader";
 import { IRequest } from "@fluidframework/core-interfaces";
@@ -24,21 +24,21 @@ import { fluidEntryPoint, LocalCodeLoader } from "./localCodeLoader";
  * @param options - loader options
  */
 export function createLoader(
-    packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>,
-    documentServiceFactory: IDocumentServiceFactory,
-    urlResolver: IUrlResolver,
-    logger?: ITelemetryBaseLogger,
-    options?: ILoaderOptions,
+	packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>,
+	documentServiceFactory: IDocumentServiceFactory,
+	urlResolver: IUrlResolver,
+	logger?: ITelemetryBaseLogger,
+	options?: ILoaderOptions,
 ): IHostLoader {
-    const codeLoader: ICodeDetailsLoader = new LocalCodeLoader(packageEntries);
+	const codeLoader: ICodeDetailsLoader = new LocalCodeLoader(packageEntries);
 
-    return new Loader({
-        urlResolver,
-        documentServiceFactory,
-        codeLoader,
-        logger,
-        options,
-    });
+	return new Loader({
+		urlResolver,
+		documentServiceFactory,
+		codeLoader,
+		logger,
+		options,
+	});
 }
 
 /**
@@ -49,12 +49,12 @@ export function createLoader(
  */
 
 export async function createAndAttachContainer(
-    source: IFluidCodeDetails,
-    loader: IHostLoader,
-    attachRequest: IRequest,
+	source: IFluidCodeDetails,
+	loader: IHostLoader,
+	attachRequest: IRequest,
 ): Promise<IContainer> {
-    const container = await loader.createDetachedContainer(source);
-    await container.attach(attachRequest);
+	const container = await loader.createDetachedContainer(source);
+	await container.attach(attachRequest);
 
-    return container;
+	return container;
 }

package/src/packageVersion.ts

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

package/src/retry.ts

@@ -6,21 +6,21 @@
 import { delay } from "@fluidframework/common-utils";
 
 const retry = async <T>(
-    callback: () => Promise<T>,
-    defaultValue: T,
-    maxTries: number,
-    backOffMs: number,
+	callback: () => Promise<T>,
+	defaultValue: T,
+	maxTries: number,
+	backOffMs: number,
 ): Promise<T> => {
-    for (let currentTry = 1; currentTry <= maxTries; currentTry++) {
-        try {
-            const result = await callback();
-            return result;
-        } catch (error) {
-            await delay(currentTry * backOffMs);
-        }
-    }
+	for (let currentTry = 1; currentTry <= maxTries; currentTry++) {
+		try {
+			const result = await callback();
+			return result;
+		} catch (error) {
+			await delay(currentTry * backOffMs);
+		}
+	}
 
-    return Promise.resolve(defaultValue);
+	return Promise.resolve(defaultValue);
 };
 
 /**
@@ -35,16 +35,22 @@ const retry = async <T>(
  * @returns the actual value from the callback when successful or the default value otherwise
  */
 export const retryWithEventualValue = async <T>(
-    callback: () => Promise<T>,
-    check: (value: T) => boolean,
-    defaultValue: T,
-    maxTries = 20,
-    backOffMs = 50,
-): Promise<T> => retry(async () => {
-    const value = await callback();
-    if (check(value)) {
-        return value;
-    }
+	callback: () => Promise<T>,
+	check: (value: T) => boolean,
+	defaultValue: T,
+	maxTries = 20,
+	backOffMs = 50,
+): Promise<T> =>
+	retry(
+		async () => {
+			const value = await callback();
+			if (check(value)) {
+				return value;
+			}
 
-    throw Error("Not ready");
-}, defaultValue, maxTries, backOffMs);
+			throw Error("Not ready");
+		},
+		defaultValue,
+		maxTries,
+		backOffMs,
+	);

package/src/testContainerRuntimeFactory.ts

@@ -6,74 +6,77 @@
 import { defaultRouteRequestHandler } from "@fluidframework/aqueduct";
 import { IContainerContext, IRuntime } from "@fluidframework/container-definitions";
 import {
-    ContainerRuntime,
-    IContainerRuntimeOptions,
-    DefaultSummaryConfiguration,
+	ContainerRuntime,
+	IContainerRuntimeOptions,
+	DefaultSummaryConfiguration,
 } from "@fluidframework/container-runtime";
 import { IContainerRuntime } from "@fluidframework/container-runtime-definitions";
-import {
-    buildRuntimeRequestHandler,
-    RuntimeRequestHandler } from "@fluidframework/request-handler";
+import { buildRuntimeRequestHandler, RuntimeRequestHandler } from "@fluidframework/request-handler";
 import { IFluidDataStoreFactory } from "@fluidframework/runtime-definitions";
 import { RuntimeFactoryHelper } from "@fluidframework/runtime-utils";
 
 /**
  * Create a container runtime factory class that allows you to set runtime options
  */
-export const createTestContainerRuntimeFactory = (containerRuntimeCtor: typeof ContainerRuntime) => {
-    return class extends RuntimeFactoryHelper {
-        constructor(
-            public type: string,
-            public dataStoreFactory: IFluidDataStoreFactory,
-            public runtimeOptions: IContainerRuntimeOptions = {
-                summaryOptions: {
-                    summaryConfigOverrides: {
-                        ...DefaultSummaryConfiguration,
-                        ...{
-                            initialSummarizerDelayMs: 0,
-                        },
-                    },
-                },
-            },
-            public requestHandlers: RuntimeRequestHandler[] = [],
-        ) {
-            super();
-        }
+export const createTestContainerRuntimeFactory = (
+	containerRuntimeCtor: typeof ContainerRuntime,
+) => {
+	return class extends RuntimeFactoryHelper {
+		constructor(
+			public type: string,
+			public dataStoreFactory: IFluidDataStoreFactory,
+			public runtimeOptions: IContainerRuntimeOptions = {
+				summaryOptions: {
+					summaryConfigOverrides: {
+						...DefaultSummaryConfiguration,
+						...{
+							initialSummarizerDelayMs: 0,
+						},
+					},
+				},
+			},
+			public requestHandlers: RuntimeRequestHandler[] = [],
+		) {
+			super();
+		}
 
-        public async instantiateFirstTime(runtime: ContainerRuntime): Promise<void> {
-            const rootContext = runtime.createDetachedRootDataStore([this.type], "default");
-            const rootRuntime = await this.dataStoreFactory.instantiateDataStore(rootContext, /* existing */ false);
-            await rootContext.attachRuntime(this.dataStoreFactory, rootRuntime);
-        }
+		public async instantiateFirstTime(runtime: ContainerRuntime): Promise<void> {
+			const rootContext = runtime.createDetachedRootDataStore([this.type], "default");
+			const rootRuntime = await this.dataStoreFactory.instantiateDataStore(
+				rootContext,
+				/* existing */ false,
+			);
+			await rootContext.attachRuntime(this.dataStoreFactory, rootRuntime);
+		}
 
-        public async instantiateFromExisting(runtime: ContainerRuntime): Promise<void> {
-            // Validate we can load root data stores.
-            // We should be able to load any data store that was created in initializeFirstTime!
-            await runtime.getRootDataStore("default");
-        }
+		public async instantiateFromExisting(runtime: ContainerRuntime): Promise<void> {
+			// Validate we can load root data stores.
+			// We should be able to load any data store that was created in initializeFirstTime!
+			await runtime.getRootDataStore("default");
+		}
 
-        async preInitialize(
-            context: IContainerContext,
-            existing: boolean,
-        ): Promise<IRuntime & IContainerRuntime> {
-            const runtime: ContainerRuntime = await containerRuntimeCtor.load(
-                context,
-                [
-                    ["default", Promise.resolve(this.dataStoreFactory)],
-                    [this.type, Promise.resolve(this.dataStoreFactory)],
-                ],
-                buildRuntimeRequestHandler(
-                    defaultRouteRequestHandler("default"),
-                    ...this.requestHandlers,
-                ),
-                this.runtimeOptions,
-                context.scope,
-                existing,
-            );
+		async preInitialize(
+			context: IContainerContext,
+			existing: boolean,
+		): Promise<IRuntime & IContainerRuntime> {
+			const runtime: ContainerRuntime = await containerRuntimeCtor.load(
+				context,
+				[
+					["default", Promise.resolve(this.dataStoreFactory)],
+					[this.type, Promise.resolve(this.dataStoreFactory)],
+				],
+				buildRuntimeRequestHandler(
+					defaultRouteRequestHandler("default"),
+					...this.requestHandlers,
+				),
+				this.runtimeOptions,
+				context.scope,
+				existing,
+			);
 
-            return runtime;
-        }
-    };
+			return runtime;
+		}
+	};
 };
 
 /**