@fluidframework/test-utils 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.2.0.0.245554

package/src/TestConfigs.ts

@@ -6,12 +6,34 @@
 import { ConfigTypes, IConfigProviderBase } from "@fluidframework/core-interfaces";
 
 /**
+ * Extension of IConfigProviderBase that supports setting a config value and clearing all
+ * config values for testing.
+ *
  * @internal
  */
-export const mockConfigProvider = (
-	settings: Record<string, ConfigTypes> = {},
-): IConfigProviderBase => {
+export interface ITestConfigProvider extends IConfigProviderBase {
+	/** Set a config value */
+	set: (key: string, value: ConfigTypes) => void;
+	/** Clear all config values */
+	clear: () => void;
+}
+
+/**
+ * Creates a test config provider with the ability to set configs values and clear all config values.
+ * @internal
+ */
+export const createTestConfigProvider = (): ITestConfigProvider => {
+	const settings: Record<string, ConfigTypes> = {};
 	return {
 		getRawConfig: (name: string): ConfigTypes => settings[name],
+		set: (key: string, value: ConfigTypes) => {
+			settings[key] = value;
+		},
+		clear: () => {
+			Object.keys(settings).forEach((key) => {
+				// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+				delete settings[key];
+			});
+		},
 	};
 };

package/src/TestSummaryUtils.ts

@@ -13,9 +13,9 @@ import {
 } from "@fluidframework/container-runtime";
 import {
 	ITelemetryBaseLogger,
-	FluidObject,
 	IRequest,
 	IConfigProviderBase,
+	IResponse,
 } from "@fluidframework/core-interfaces";
 import { DriverHeader } from "@fluidframework/driver-definitions";
 import {
@@ -23,15 +23,38 @@ import {
 	NamedFluidDataStoreRegistryEntries,
 } from "@fluidframework/runtime-definitions";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
-import { ITestContainerConfig, ITestObjectProvider } from "./testObjectProvider";
-import { mockConfigProvider } from "./TestConfigs";
-import { waitForContainerConnection } from "./containerUtils";
-import { timeoutAwait } from "./timeoutUtils";
-import { createContainerRuntimeFactoryWithDefaultDataStore } from "./testContainerRuntimeFactoryWithDefaultDataStore";
+import { ITestContainerConfig, ITestObjectProvider } from "./testObjectProvider.js";
+import { createTestConfigProvider } from "./TestConfigs.js";
+import { waitForContainerConnection } from "./containerUtils.js";
+import { timeoutAwait } from "./timeoutUtils.js";
+import { createContainerRuntimeFactoryWithDefaultDataStore } from "./testContainerRuntimeFactoryWithDefaultDataStore.js";
 
 const summarizerClientType = "summarizer";
 
-async function createSummarizerCore(
+/**
+ * This function should ONLY be used for back compat purposes
+ * LTS versions of the Loader/Container will not have the "getEntryPoint" method, so we need to fallback to "request"
+ * This function can be removed once LTS version of Loader moves to 2.0.0-internal.7.0.0
+ * @internal
+ */
+async function getSummarizerBackCompat(container: IContainer): Promise<ISummarizer> {
+	if (container.getEntryPoint !== undefined) {
+		const entryPoint = await container.getEntryPoint();
+		// Note: We need to also check if the result of `getEntryPoint()` is defined. This is because when running
+		// cross version compat testing scenarios, if we create with 1.X container and load with 2.X then the
+		// function container.getEntryPoint will be defined for the 2.X container. However, it will not return undefined
+		// since the container's runtime will be on version 1.X, which does not have an entry point defined.
+		if (entryPoint !== undefined) {
+			return entryPoint as ISummarizer;
+		}
+	}
+	const response: IResponse = await (container as any).request({ url: "_summarizer" });
+	assert(response.status === 200, "requesting '/' should return default data object");
+	return response.value as ISummarizer;
+}
+
+/** @internal */
+export async function createSummarizerCore(
 	container: IContainer,
 	loader: IHostLoader,
 	summaryVersion?: string,
@@ -56,9 +79,10 @@ async function createSummarizerCore(
 	const summarizerContainer = await loader.resolve(request);
 	await waitForContainerConnection(summarizerContainer);
 
-	const fluidObject: FluidObject<ISummarizer> | undefined =
-		await summarizerContainer.getEntryPoint();
-	if (fluidObject?.ISummarizer === undefined) {
+	// Old loaders will not have getEntryPoint API on the container. So, use getSummarizerBackCompat which
+	// will use request pattern to get the summarizer in these old loaders.
+	const fluidObject = await getSummarizerBackCompat(summarizerContainer);
+	if (fluidObject.ISummarizer === undefined) {
 		throw new Error("Fluid object does not implement ISummarizer");
 	}
 
@@ -91,7 +115,7 @@ export async function createSummarizerFromFactory(
 	containerRuntimeFactoryType = ContainerRuntimeFactoryWithDefaultDataStore,
 	registryEntries?: NamedFluidDataStoreRegistryEntries,
 	logger?: ITelemetryBaseLogger,
-	configProvider: IConfigProviderBase = mockConfigProvider(),
+	configProvider: IConfigProviderBase = createTestConfigProvider(),
 ): Promise<{ container: IContainer; summarizer: ISummarizer }> {
 	const runtimeFactory = createContainerRuntimeFactoryWithDefaultDataStore(
 		containerRuntimeFactoryType,
@@ -133,7 +157,7 @@ export async function createSummarizer(
 		},
 		loaderProps: {
 			...config?.loaderProps,
-			configProvider: config?.loaderProps?.configProvider ?? mockConfigProvider(),
+			configProvider: config?.loaderProps?.configProvider ?? createTestConfigProvider(),
 			logger,
 		},
 	};

package/src/containerUtils.ts

@@ -8,7 +8,7 @@ import { ConnectionState } from "@fluidframework/container-loader";
 import { IResponse } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils";
 import { IDataStore } from "@fluidframework/runtime-definitions";
-import { PromiseExecutor, timeoutPromise, TimeoutWithError } from "./timeoutUtils";
+import { PromiseExecutor, timeoutPromise, TimeoutWithError } from "./timeoutUtils.js";
 
 /**
  * Utility function to wait for the specified Container to be in Connected state.

package/src/debug.ts

@@ -4,7 +4,7 @@
  */
 
 import registerDebug from "debug";
-import { pkgName, pkgVersion } from "./packageVersion";
+import { pkgName, pkgVersion } from "./packageVersion.js";
 
 export const debug = registerDebug("fluid:test-utils");
 debug(`Package: ${pkgName} - Version: ${pkgVersion}`);

package/src/index.ts

@@ -7,18 +7,22 @@ export {
 	wrapDocumentService,
 	wrapDocumentServiceFactory,
 	wrapDocumentStorageService,
-} from "./DriverWrappers";
-export { IProvideTestFluidObject, ITestFluidObject } from "./interfaces";
-export { LoaderContainerTracker } from "./loaderContainerTracker";
-export { fluidEntryPoint, LocalCodeLoader, SupportedExportInterfaces } from "./localCodeLoader";
-export { createAndAttachContainer, createLoader } from "./localLoader";
-export { retryWithEventualValue } from "./retry";
-export { mockConfigProvider } from "./TestConfigs";
+} from "./DriverWrappers.js";
+export { IProvideTestFluidObject, ITestFluidObject } from "./interfaces.js";
+export { LoaderContainerTracker } from "./loaderContainerTracker.js";
+export { fluidEntryPoint, LocalCodeLoader, SupportedExportInterfaces } from "./localCodeLoader.js";
+export { createAndAttachContainer, createLoader } from "./localLoader.js";
+export { retryWithEventualValue } from "./retry.js";
+export { createTestConfigProvider, ITestConfigProvider } from "./TestConfigs.js";
 export {
 	createTestContainerRuntimeFactory,
 	TestContainerRuntimeFactory,
-} from "./testContainerRuntimeFactory";
-export { ChannelFactoryRegistry, TestFluidObject, TestFluidObjectFactory } from "./testFluidObject";
+} from "./testContainerRuntimeFactory.js";
+export {
+	ChannelFactoryRegistry,
+	TestFluidObject,
+	TestFluidObjectFactory,
+} from "./testFluidObject.js";
 export {
 	createDocumentId,
 	DataObjectFactoryType,
@@ -30,23 +34,24 @@ export {
 	ITestObjectProvider,
 	TestObjectProvider,
 	TestObjectProviderWithVersionedLoad,
-} from "./testObjectProvider";
+} from "./testObjectProvider.js";
 export {
 	createSummarizer,
+	createSummarizerCore,
 	createSummarizerFromFactory,
 	summarizeNow,
 	SummaryInfo,
-} from "./TestSummaryUtils";
+} from "./TestSummaryUtils.js";
 export {
 	defaultTimeoutDurationMs,
 	timeoutAwait,
 	timeoutPromise,
 	TimeoutWithError,
 	TimeoutWithValue,
-} from "./timeoutUtils";
+} from "./timeoutUtils.js";
 export {
 	waitForContainerConnection,
 	getContainerEntryPointBackCompat,
 	getDataStoreEntryPointBackCompat,
-} from "./containerUtils";
-export { createContainerRuntimeFactoryWithDefaultDataStore } from "./testContainerRuntimeFactoryWithDefaultDataStore";
+} from "./containerUtils.js";
+export { createContainerRuntimeFactoryWithDefaultDataStore } from "./testContainerRuntimeFactoryWithDefaultDataStore.js";

package/src/loaderContainerTracker.ts

@@ -15,11 +15,11 @@ import {
 	IContainerCreateProps,
 	IContainerLoadProps,
 	// eslint-disable-next-line import/no-internal-modules
-} from "@fluidframework/container-loader/dist/container";
-import { waitForContainerConnection } from "./containerUtils";
-import { debug } from "./debug";
-import { IOpProcessingController } from "./testObjectProvider";
-import { timeoutAwait, timeoutPromise } from "./timeoutUtils";
+} from "@fluidframework/container-loader/test/container";
+import { waitForContainerConnection } from "./containerUtils.js";
+import { debug } from "./debug.js";
+import { IOpProcessingController } from "./testObjectProvider.js";
+import { timeoutAwait, timeoutPromise } from "./timeoutUtils.js";
 
 const debugOp = debug.extend("ops");
 const debugWait = debug.extend("wait");

package/src/localLoader.ts

@@ -13,7 +13,7 @@ import {
 import { Loader } from "@fluidframework/container-loader";
 import { ITelemetryBaseLogger, IRequest } from "@fluidframework/core-interfaces";
 import { IDocumentServiceFactory, IUrlResolver } from "@fluidframework/driver-definitions";
-import { fluidEntryPoint, LocalCodeLoader } from "./localCodeLoader";
+import { fluidEntryPoint, LocalCodeLoader } from "./localCodeLoader.js";
 
 /**
  * Creates a loader with the given package entries and driver.

package/src/packageVersion.ts

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

package/src/testContainerRuntimeFactory.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import { assert } from "@fluidframework/core-utils";
 import { IContainerContext, IRuntime } from "@fluidframework/container-definitions";
 import {
 	ContainerRuntime,
@@ -83,12 +84,21 @@ export const createTestContainerRuntimeFactory = (
 		}
 
 		public async instantiateFirstTime(runtime: ContainerRuntime): Promise<void> {
-			const rootContext = runtime.createDetachedRootDataStore([this.type], "default");
+			// Back-compat - old code does not return IDataStore for rootContext.attachRuntime() call!
+			// Thus need to leverage old API createDetachedRootDataStore() that is gone in latest releases.
+			const rootContext =
+				"createDetachedRootDataStore" in runtime
+					? (runtime as any).createDetachedRootDataStore([this.type], "default")
+					: runtime.createDetachedDataStore([this.type], "default");
+
 			const rootRuntime = await this.dataStoreFactory.instantiateDataStore(
 				rootContext,
 				/* existing */ false,
 			);
-			await rootContext.attachRuntime(this.dataStoreFactory, rootRuntime);
+			const dataStore = await rootContext.attachRuntime(this.dataStoreFactory, rootRuntime);
+
+			const result = await dataStore?.trySetAlias("default");
+			assert(result === "Success" || result === undefined, "success");
 		}
 
 		public async instantiateFromExisting(runtime: ContainerRuntime): Promise<void> {

package/src/testFluidObject.ts

@@ -18,7 +18,7 @@ import {
 import { IFluidDataStoreRuntime, IChannelFactory } from "@fluidframework/datastore-definitions";
 import { assert } from "@fluidframework/core-utils";
 import { create404Response } from "@fluidframework/runtime-utils";
-import { ITestFluidObject } from "./interfaces";
+import { ITestFluidObject } from "./interfaces.js";
 
 /**
  * A test Fluid object that will create a shared object for each key-value pair in the factoryEntries passed to load.

package/src/testObjectProvider.ts

@@ -16,7 +16,6 @@ import {
 } from "@fluidframework/container-loader";
 import { IContainerRuntimeOptions } from "@fluidframework/container-runtime";
 import {
-	ITelemetryGenericEvent,
 	ITelemetryBaseLogger,
 	ITelemetryBaseEvent,
 	IRequestHeader,
@@ -28,11 +27,15 @@ import {
 } from "@fluidframework/driver-definitions";
 import { ITestDriver, TestDriverTypes } from "@fluidframework/test-driver-definitions";
 import { v4 as uuid } from "uuid";
-import { createChildLogger, createMultiSinkLogger } from "@fluidframework/telemetry-utils";
-import { LoaderContainerTracker } from "./loaderContainerTracker";
-import { fluidEntryPoint, LocalCodeLoader } from "./localCodeLoader";
-import { createAndAttachContainer } from "./localLoader";
-import { ChannelFactoryRegistry } from "./testFluidObject";
+import {
+	createChildLogger,
+	createMultiSinkLogger,
+	type ITelemetryGenericEventExt,
+} from "@fluidframework/telemetry-utils";
+import { LoaderContainerTracker } from "./loaderContainerTracker.js";
+import { fluidEntryPoint, LocalCodeLoader } from "./localCodeLoader.js";
+import { createAndAttachContainer } from "./localLoader.js";
+import { ChannelFactoryRegistry } from "./testFluidObject.js";
 
 const defaultCodeDetails: IFluidCodeDetails = {
 	package: "defaultTestPackage",
@@ -126,6 +129,19 @@ export interface ITestObjectProvider {
 		loaderProps?: Partial<ILoaderProps>,
 	): Promise<IContainer>;
 
+	/**
+	 * Create a detached container much like createContainer, but without attaching it to the document service.
+	 */
+	createDetachedContainer(
+		entryPoint: fluidEntryPoint,
+		loaderProps?: Partial<ILoaderProps>,
+	): Promise<IContainer>;
+
+	/**
+	 * Attaches a detached container to the document service.
+	 */
+	attachDetachedContainer(container: IContainer): Promise<void>;
+
 	/**
 	 * Loads a container using the default document id
 	 */
@@ -288,12 +304,12 @@ export class EventAndErrorTrackingLogger implements ITelemetryBaseLogger {
 	constructor(private readonly baseLogger: ITelemetryBaseLogger) {}
 
 	private readonly expectedEvents: (
-		| { index: number; event: ITelemetryGenericEvent | undefined }
+		| { index: number; event: ITelemetryGenericEventExt | undefined }
 		| undefined
 	)[] = [];
 	private readonly unexpectedErrors: ITelemetryBaseEvent[] = [];
 
-	public registerExpectedEvent(...orderedExpectedEvents: ITelemetryGenericEvent[]) {
+	public registerExpectedEvent(...orderedExpectedEvents: ITelemetryGenericEventExt[]) {
 		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.
@@ -505,6 +521,36 @@ export class TestObjectProvider implements ITestObjectProvider {
 		return container;
 	}
 
+	/**
+	 * {@inheritdoc ITestObjectProvider.createDetachedContainer}
+	 */
+	public async createDetachedContainer(
+		entryPoint: fluidEntryPoint,
+		loaderProps?: Partial<ILoaderProps> | undefined,
+	): Promise<IContainer> {
+		if (this._documentCreated) {
+			throw new Error(
+				"Only one container/document can be created. To load the container/document use loadContainer",
+			);
+		}
+		const loader = this.createLoader([[defaultCodeDetails, entryPoint]], loaderProps);
+		return loader.createDetachedContainer(defaultCodeDetails);
+	}
+
+	/**
+	 * {@inheritdoc ITestObjectProvider.attachDetachedContainer}
+	 */
+	public async attachDetachedContainer(container: IContainer): Promise<void> {
+		if (this._documentCreated) {
+			throw new Error(
+				"Only one container/document can be created. To load the container/document use loadContainer",
+			);
+		}
+		await container.attach(this.driver.createCreateNewRequest(this.documentId));
+		this._documentCreated = true;
+		this._documentIdStrategy.update(container.resolvedUrl);
+	}
+
 	/**
 	 * {@inheritDoc ITestObjectProvider.loadContainer}
 	 */
@@ -643,14 +689,12 @@ export class TestObjectProviderWithVersionedLoad implements ITestObjectProvider
 	private _documentCreated = false;
 
 	/**
-	 * `_loadCount` is used to alternate which version we load the next container with.
-	 * loadCount is even then we will load with the "create" version, and if odd we load with the "load" version.
-	 * After each test we will reset loadCount to 0 to ensure we always create the first container with the create version.
+	 * Used to determine which APIs to use when creating a loader.
 	 *
-	 * Note: This will only affect tests that load a container more than two times.
+	 * The first load will always use the create APIs, and then useCreateApi will be set to false to ensure all
+	 * subsequent loads use the load APIs.
 	 */
-
-	private _loadCount: number = 0;
+	private useCreateApi: boolean = true;
 
 	constructor(
 		private readonly LoaderConstructorForCreating: typeof Loader,
@@ -726,7 +770,7 @@ export class TestObjectProviderWithVersionedLoad implements ITestObjectProvider
 	 * {@inheritDoc ITestObjectProvider.driver}
 	 */
 	public get driver(): ITestDriver {
-		return this.nextLoaderShouldCreate() ? this.driverForCreating : this.driverForLoading;
+		return this.useCreateApi ? this.driverForCreating : this.driverForLoading;
 	}
 
 	/**
@@ -735,7 +779,7 @@ export class TestObjectProviderWithVersionedLoad implements ITestObjectProvider
 	public get createFluidEntryPoint(): (
 		testContainerConfig?: ITestContainerConfig,
 	) => fluidEntryPoint {
-		return this.nextLoaderShouldCreate()
+		return this.useCreateApi
 			? this.createFluidEntryPointForCreating
 			: this.createFluidEntryPointForLoading;
 	}
@@ -789,9 +833,12 @@ export class TestObjectProviderWithVersionedLoad implements ITestObjectProvider
 		packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>,
 		loaderProps?: Partial<ILoaderProps>,
 	) {
-		return this.nextLoaderShouldCreate(/** increment */ true)
-			? this.createLoaderForCreating(packageEntries, loaderProps)
-			: this.createLoaderForLoading(packageEntries, loaderProps);
+		if (this.useCreateApi) {
+			// After we create the first loader, we can set this.useCreateApi to false.
+			this.useCreateApi = false;
+			return this.createLoaderForCreating(packageEntries, loaderProps);
+		}
+		return this.createLoaderForLoading(packageEntries, loaderProps);
 	}
 
 	/**
@@ -816,6 +863,36 @@ export class TestObjectProviderWithVersionedLoad implements ITestObjectProvider
 		return container;
 	}
 
+	/**
+	 * {@inheritdoc ITestObjectProvider.createDetachedContainer}
+	 */
+	public async createDetachedContainer(
+		entryPoint: fluidEntryPoint,
+		loaderProps?: Partial<ILoaderProps> | undefined,
+	): Promise<IContainer> {
+		if (this._documentCreated) {
+			throw new Error(
+				"Only one container/document can be created. To load the container/document use loadContainer",
+			);
+		}
+		const loader = this.createLoader([[defaultCodeDetails, entryPoint]], loaderProps);
+		return loader.createDetachedContainer(defaultCodeDetails);
+	}
+
+	/**
+	 * {@inheritdoc ITestObjectProvider.attachDetachedContainer}
+	 */
+	public async attachDetachedContainer(container: IContainer): Promise<void> {
+		if (this._documentCreated) {
+			throw new Error(
+				"Only one container/document can be created. To load the container/document use loadContainer",
+			);
+		}
+		await container.attach(this.driver.createCreateNewRequest(this.documentId));
+		this._documentCreated = true;
+		this._documentIdStrategy.update(container.resolvedUrl);
+	}
+
 	/**
 	 * {@inheritDoc ITestObjectProvider.loadContainer}
 	 */
@@ -824,9 +901,7 @@ export class TestObjectProviderWithVersionedLoad implements ITestObjectProvider
 		loaderProps?: Partial<ILoaderProps>,
 		requestHeader?: IRequestHeader,
 	): Promise<IContainer> {
-		const driver = this.nextLoaderShouldCreate()
-			? this.driverForCreating
-			: this.driverForLoading;
+		const driver = this.useCreateApi ? this.driverForCreating : this.driverForLoading;
 		const loader = this.createLoader([[defaultCodeDetails, entryPoint]], loaderProps);
 		return this.resolveContainer(loader, requestHeader, driver);
 	}
@@ -888,9 +963,7 @@ export class TestObjectProviderWithVersionedLoad implements ITestObjectProvider
 		requestHeader?: IRequestHeader,
 	): Promise<IContainer> {
 		// Keep track of which Loader we are about to use so we can pass the correct driver through
-		const driver = this.nextLoaderShouldCreate()
-			? this.driverForCreating
-			: this.driverForLoading;
+		const driver = this.useCreateApi ? this.driverForCreating : this.driverForLoading;
 		const loader = this.makeTestLoader(testContainerConfig);
 		const container = await this.resolveContainer(loader, requestHeader, driver);
 		await this.waitContainerToCatchUp(container);
@@ -902,7 +975,7 @@ export class TestObjectProviderWithVersionedLoad implements ITestObjectProvider
 	 * {@inheritDoc ITestObjectProvider.reset}
 	 */
 	public reset() {
-		this._loadCount = 0;
+		this.useCreateApi = true;
 		this._loaderContainerTracker.reset();
 		this._logger = undefined;
 		this._documentServiceFactory = undefined;
@@ -948,14 +1021,6 @@ export class TestObjectProviderWithVersionedLoad implements ITestObjectProvider
 		this._loaderContainerTracker.reset();
 		this._loaderContainerTracker = new LoaderContainerTracker(syncSummarizerClients);
 	}
-
-	private nextLoaderShouldCreate(increment: boolean = false): boolean {
-		const shouldCreate = this._loadCount % 2 === 0;
-		if (increment) {
-			this._loadCount++;
-		}
-		return shouldCreate;
-	}
 }
 
 /**

package/src/timeoutUtils.ts

@@ -4,6 +4,7 @@
  */
 
 import { assert, Deferred } from "@fluidframework/core-utils";
+import type * as Mocha from "mocha";
 
 // @deprecated this value is no longer used
 /**

package/tsconfig.cjs.json

@@ -0,0 +1,7 @@
+{
+	// This config must be used in a "type": "commonjs" environment. (Use fluid-tsc commonjs.)
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+	},
+}

package/tsconfig.json

@@ -1,11 +1,10 @@
 {
-	"extends": "@fluidframework/build-common/ts-common-config.json",
+	"extends": "../../../common/build/build-common/tsconfig.node16.json",
 	"exclude": ["src/test/**/*"],
 	"compilerOptions": {
 		"rootDir": "./src",
-		"outDir": "./dist",
-		"composite": true,
-		"types": ["mocha", "node"],
+		"outDir": "./lib",
+		"types": ["node"],
 	},
 	"include": ["src/**/*"],
 }