@fluidframework/test-utils 1.4.0-115997 → 2.0.0-dev-rc.1.0.0.224419

package/src/localCodeLoader.ts

@@ -6,110 +6,111 @@
 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 {
+	IProvideFluidDataStoreFactory,
+	IProvideFluidDataStoreRegistry,
+} from "@fluidframework/runtime-definitions";
 import { createDataStoreFactory } from "@fluidframework/runtime-utils";
 import { IContainerRuntimeOptions } from "@fluidframework/container-runtime";
 
+/**
+ * @internal
+ */
 export type SupportedExportInterfaces = Partial<
-    IProvideRuntimeFactory &
-    IProvideFluidDataStoreFactory &
-    IProvideFluidDataStoreRegistry &
-    IProvideFluidCodeDetailsComparer>;
+	IProvideRuntimeFactory &
+		IProvideFluidDataStoreFactory &
+		IProvideFluidDataStoreRegistry &
+		IProvideFluidCodeDetailsComparer
+>;
 
 // Represents the entry point for a Fluid container.
+/**
+ * @internal
+ */
 export type fluidEntryPoint = SupportedExportInterfaces | IFluidModule;
 
 /**
  * A simple code loader that caches a mapping of package name to a Fluid entry point.
  * On load, it retrieves the entry point matching the package name in the given code details.
+ * @internal
  */
 export class LocalCodeLoader implements ICodeDetailsLoader {
-    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.
-            let pkgId: string;
-
-            const source = entry[0];
-            if (typeof source.package === "string") {
-                pkgId = source.package;
-            } else {
-                pkgId = `${source.package.name}@${source.package.version}`;
-            }
-            let fluidModule = entry[1] as IFluidModule;
-            if (fluidModule?.fluidExport === undefined) {
-                const maybeExport = fluidModule as SupportedExportInterfaces;
+	private readonly fluidPackageCache = new Map<string, IFluidModuleWithDetails>();
 
-                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,
-                                ),
-                        },
-                    };
-                }
-            }
+	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;
 
-            const runtimeFactory = {
-                module: fluidModule,
-                details: source,
-            };
+				if (maybeExport.IRuntimeFactory !== undefined) {
+					fluidModule = { fluidExport: maybeExport };
+				} else {
+					assert(maybeExport.IFluidDataStoreFactory !== undefined);
+					const defaultFactory = createDataStoreFactory(
+						"default",
+						maybeExport.IFluidDataStoreFactory,
+					);
+					fluidModule = {
+						fluidExport: {
+							...maybeExport,
+							IRuntimeFactory: new ContainerRuntimeFactoryWithDefaultDataStore({
+								defaultFactory,
+								registryEntries: [
+									[defaultFactory.type, Promise.resolve(defaultFactory)],
+								],
+								runtimeOptions,
+							}),
+						},
+					};
+				}
+			}
 
-            this.fluidPackageCache.set(pkgId, runtimeFactory);
-        }
-    }
+			const runtimeFactory = {
+				module: fluidModule,
+				details: source,
+			};
 
-    /**
-     * 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.
-        let pkdId: string;
+			this.fluidPackageCache.set(pkgId, runtimeFactory);
+		}
+	}
 
-        if (typeof source.package === "string") {
-            pkdId = source.package;
-        } else {
-            pkdId = `${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,16 +4,15 @@
  */
 
 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";
+import { ITelemetryBaseLogger, IRequest } from "@fluidframework/core-interfaces";
 import { IDocumentServiceFactory, IUrlResolver } from "@fluidframework/driver-definitions";
-import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
 import { fluidEntryPoint, LocalCodeLoader } from "./localCodeLoader";
 
 /**
@@ -22,23 +21,24 @@ import { fluidEntryPoint, LocalCodeLoader } from "./localCodeLoader";
  * @param documentServiceFactory - the driver factory to use
  * @param urlResolver - the url resolver to use
  * @param options - loader options
+ * @internal
  */
 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,
+	});
 }
 
 /**
@@ -46,15 +46,16 @@ export function createLoader(
  * @param source - The code details used to create the Container.
  * @param loader - The loader to use to initialize the container.
  * @param attachRequest - The request to create new from.
+ * @alpha
  */
 
 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 = "1.4.0-115997";
+export const pkgVersion = "2.0.0-dev-rc.1.0.0.224419";

package/src/retry.ts

@@ -3,24 +3,24 @@
  * Licensed under the MIT License.
  */
 
-import { delay } from "@fluidframework/common-utils";
+import { delay } from "@fluidframework/core-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);
 };
 
 /**
@@ -33,18 +33,25 @@ const retry = async <T>(
  * @param maxTries - maximum number of attempts
  * @param backOffMs - back off between attempts in milliseconds
  * @returns the actual value from the callback when successful or the default value otherwise
+ * @internal
  */
 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

@@ -3,80 +3,173 @@
  * Licensed under the MIT License.
  */
 
-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 { IFluidDataStoreFactory } from "@fluidframework/runtime-definitions";
-import { RuntimeFactoryHelper } from "@fluidframework/runtime-utils";
+	FluidObject,
+	IFluidHandleContext,
+	IRequest,
+	IResponse,
+} from "@fluidframework/core-interfaces";
+// eslint-disable-next-line import/no-deprecated
+import { buildRuntimeRequestHandler, RuntimeRequestHandler } from "@fluidframework/request-handler";
+import {
+	IFluidDataStoreFactory,
+	NamedFluidDataStoreRegistryEntries,
+} from "@fluidframework/runtime-definitions";
+import { RequestParser, RuntimeFactoryHelper } from "@fluidframework/runtime-utils";
+
+interface backCompat_IFluidRouter {
+	IFluidRouter?: backCompat_IFluidRouter;
+	request(request: IRequest): Promise<IResponse>;
+}
+
+const backCompat_DefaultRouteRequestHandler = (defaultRootId: string) => {
+	return async (request: IRequest, runtime: IContainerRuntime) => {
+		const parser = RequestParser.create(request);
+		if (parser.pathParts.length === 0) {
+			return (
+				runtime as any as Required<FluidObject<IFluidHandleContext>>
+			).IFluidHandleContext.resolveHandle({
+				url: `/${defaultRootId}${parser.query}`,
+				headers: request.headers,
+			});
+		}
+		return undefined; // continue search
+	};
+};
+
+interface backCompat_ContainerRuntime {
+	load(
+		context: IContainerContext,
+		registryEntries: NamedFluidDataStoreRegistryEntries,
+		requestHandler?: (request: IRequest, runtime: IContainerRuntime) => Promise<IResponse>,
+		runtimeOptions?: IContainerRuntimeOptions,
+		containerScope?: FluidObject,
+		existing?: boolean,
+		containerRuntimeCtor?: typeof ContainerRuntime,
+	): Promise<ContainerRuntime>;
+}
 
 /**
  * Create a container runtime factory class that allows you to set runtime options
+ * @internal
  */
-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);
-        }
+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 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 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);
+		}
 
-        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,
-                undefined, // containerScope
-                existing,
-            );
+		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!
+			// Note: We use the deprecated `getRootDataStore` from v1.X here to allow for cross-major version compat
+			// testing. Can be removed when we no longer support v1.X.
+			await (runtime.getAliasedDataStoreEntryPoint?.("default") ??
+				(
+					runtime as any as {
+						getRootDataStore(
+							id: string,
+							wait?: boolean,
+						): Promise<backCompat_IFluidRouter>;
+					}
+				).getRootDataStore("default"));
+		}
 
-            return runtime;
-        }
-    };
+		async preInitialize(
+			context: IContainerContext,
+			existing: boolean,
+		): Promise<IRuntime & IContainerRuntime> {
+			if (containerRuntimeCtor.loadRuntime === undefined) {
+				// Note: We use the deprecated `load` from v1.X here to allow for cross-major version compat testing.
+				// Can be removed when we no longer support v1.X.
+				return (containerRuntimeCtor as any as backCompat_ContainerRuntime).load(
+					context,
+					[
+						["default", Promise.resolve(this.dataStoreFactory)],
+						[this.type, Promise.resolve(this.dataStoreFactory)],
+					],
+					buildRuntimeRequestHandler(
+						backCompat_DefaultRouteRequestHandler("default"),
+						...this.requestHandlers,
+					),
+					this.runtimeOptions,
+					context.scope,
+					existing,
+				);
+			}
+			const provideEntryPoint = async (runtime: IContainerRuntime) => {
+				const entryPoint = await runtime.getAliasedDataStoreEntryPoint("default");
+				if (entryPoint === undefined) {
+					throw new Error("default dataStore must exist");
+				}
+				return entryPoint.get();
+			};
+			const getDefaultObject = async (request: IRequest, runtime: IContainerRuntime) => {
+				const parser = RequestParser.create(request);
+				if (parser.pathParts.length === 0) {
+					// This cast is safe as ContainerRuntime.loadRuntime is called below
+					return (runtime as ContainerRuntime).resolveHandle({
+						url: `/default${parser.query}`,
+						headers: request.headers,
+					});
+				}
+				return undefined; // continue search
+			};
+			return containerRuntimeCtor.loadRuntime({
+				context,
+				registryEntries: [
+					["default", Promise.resolve(this.dataStoreFactory)],
+					[this.type, Promise.resolve(this.dataStoreFactory)],
+				],
+				requestHandler: buildRuntimeRequestHandler(
+					getDefaultObject,
+					...this.requestHandlers,
+				),
+				provideEntryPoint,
+				// ! This prop is needed for back-compat. Can be removed in 2.0.0-internal.8.0.0
+				initializeEntryPoint: provideEntryPoint,
+				runtimeOptions: this.runtimeOptions,
+				containerScope: context.scope,
+				existing,
+			} as any);
+		}
+	};
 };
 
 /**
  * A container runtime factory that allows you to set runtime options
+ * @internal
  */
 export const TestContainerRuntimeFactory = createTestContainerRuntimeFactory(ContainerRuntime);

package/src/testContainerRuntimeFactoryWithDefaultDataStore.ts

@@ -0,0 +1,61 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ContainerRuntimeFactoryWithDefaultDataStore } from "@fluidframework/aqueduct";
+import { IContainerRuntimeOptions } from "@fluidframework/container-runtime";
+import { IContainerRuntime } from "@fluidframework/container-runtime-definitions";
+import { FluidObject } from "@fluidframework/core-interfaces";
+import { RuntimeRequestHandler } from "@fluidframework/request-handler";
+import {
+	IFluidDataStoreFactory,
+	NamedFluidDataStoreRegistryEntries,
+} from "@fluidframework/runtime-definitions";
+
+const getDefaultFluidObject = async (runtime: IContainerRuntime) => {
+	const entryPoint = await runtime.getAliasedDataStoreEntryPoint("default");
+	if (entryPoint === undefined) {
+		throw new Error("default dataStore must exist");
+	}
+	return entryPoint.get();
+};
+
+/**
+ * ! Note: This function is purely needed for back-compat as the constructor argument structure was changed
+ * @internal
+ */
+export const createContainerRuntimeFactoryWithDefaultDataStore = (
+	Base: typeof ContainerRuntimeFactoryWithDefaultDataStore = ContainerRuntimeFactoryWithDefaultDataStore,
+	ctorArgs: {
+		defaultFactory: IFluidDataStoreFactory;
+		registryEntries: NamedFluidDataStoreRegistryEntries;
+		dependencyContainer?: any;
+		requestHandlers?: RuntimeRequestHandler[];
+		runtimeOptions?: IContainerRuntimeOptions;
+		provideEntryPoint?: (runtime: IContainerRuntime) => Promise<FluidObject>;
+	},
+): ContainerRuntimeFactoryWithDefaultDataStore => {
+	try {
+		return new Base(ctorArgs);
+	} catch (err) {
+		// IMPORTANT: The constructor argument structure changed, so this is needed for dynamically using older ContainerRuntimeFactoryWithDefaultDataStore's
+		const {
+			defaultFactory,
+			registryEntries,
+			dependencyContainer,
+			requestHandlers,
+			runtimeOptions,
+			provideEntryPoint,
+		} = ctorArgs;
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+		return new (Base as any)(
+			defaultFactory,
+			registryEntries,
+			dependencyContainer,
+			requestHandlers,
+			runtimeOptions,
+			provideEntryPoint ?? getDefaultFluidObject,
+		);
+	}
+};