@fluidframework/test-utils 2.0.0-internal.6.3.3 → 2.0.0-internal.7.0.0

package/src/TestSummaryUtils.ts

@@ -6,7 +6,11 @@
 import { ContainerRuntimeFactoryWithDefaultDataStore } from "@fluidframework/aqueduct";
 import { assert } from "@fluidframework/core-utils";
 import { IContainer, IHostLoader, LoaderHeader } from "@fluidframework/container-definitions";
-import { ISummarizer, ISummaryRuntimeOptions } from "@fluidframework/container-runtime";
+import {
+	IOnDemandSummarizeOptions,
+	ISummarizer,
+	ISummaryRuntimeOptions,
+} from "@fluidframework/container-runtime";
 import { ITelemetryBaseLogger, FluidObject, IRequest } from "@fluidframework/core-interfaces";
 import { DriverHeader } from "@fluidframework/driver-definitions";
 import {
@@ -15,11 +19,11 @@ import {
 	NamedFluidDataStoreRegistryEntries,
 } from "@fluidframework/runtime-definitions";
 import { IConfigProviderBase } from "@fluidframework/telemetry-utils";
-import { requestFluidObject } from "@fluidframework/runtime-utils";
 import { ITestContainerConfig, ITestObjectProvider } from "./testObjectProvider";
 import { mockConfigProvider } from "./TestConfigs";
 import { waitForContainerConnection } from "./containerUtils";
 import { timeoutAwait } from "./timeoutUtils";
+import { createContainerRuntimeFactoryWithDefaultDataStore } from "./testContainerRuntimeFactoryWithDefaultDataStore";
 
 const summarizerClientType = "summarizer";
 
@@ -48,11 +52,8 @@ async function createSummarizerCore(
 	const summarizerContainer = await loader.resolve(request);
 	await waitForContainerConnection(summarizerContainer);
 
-	const fluidObject: FluidObject<ISummarizer> | undefined = summarizerContainer.getEntryPoint
-		? await summarizerContainer.getEntryPoint?.()
-		: await requestFluidObject<FluidObject<ISummarizer>>(summarizerContainer, {
-				url: "_summarizer",
-		  });
+	const fluidObject: FluidObject<ISummarizer> | undefined =
+		await summarizerContainer.getEntryPoint();
 	if (fluidObject?.ISummarizer === undefined) {
 		throw new Error("Fluid object does not implement ISummarizer");
 	}
@@ -89,12 +90,16 @@ export async function createSummarizerFromFactory(
 ): Promise<{ container: IContainer; summarizer: ISummarizer }> {
 	const innerRequestHandler = async (request: IRequest, runtime: IContainerRuntimeBase) =>
 		runtime.IFluidHandleContext.resolveHandle(request);
-	const runtimeFactory = new containerRuntimeFactoryType(
-		dataStoreFactory,
-		registryEntries ?? [[dataStoreFactory.type, Promise.resolve(dataStoreFactory)]],
-		undefined,
-		[innerRequestHandler],
-		{ summaryOptions: defaultSummaryOptions },
+	const runtimeFactory = createContainerRuntimeFactoryWithDefaultDataStore(
+		containerRuntimeFactoryType,
+		{
+			defaultFactory: dataStoreFactory,
+			registryEntries: registryEntries ?? [
+				[dataStoreFactory.type, Promise.resolve(dataStoreFactory)],
+			],
+			requestHandlers: [innerRequestHandler],
+			runtimeOptions: { summaryOptions: defaultSummaryOptions },
+		},
 	);
 
 	const loader = provider.createLoader([[provider.defaultCodeDetails, runtimeFactory]], {
@@ -136,9 +141,18 @@ export async function createSummarizer(
 /**
  * Summarizes on demand and returns the summary tree, the version number and the reference sequence number of the
  * submitted summary.
+ *
+ * @param summarizer - The ISummarizer to use to summarize on demand
+ * @param inputs - Either the reason string or the full IOnDemandSummarizeOptions.
+ * Defaults to the reason "end-to-end test".
  */
-export async function summarizeNow(summarizer: ISummarizer, reason: string = "end-to-end test") {
-	const result = summarizer.summarizeOnDemand({ reason });
+export async function summarizeNow(
+	summarizer: ISummarizer,
+	inputs: string | IOnDemandSummarizeOptions = "end-to-end test",
+) {
+	const options: IOnDemandSummarizeOptions =
+		typeof inputs === "string" ? { reason: inputs } : inputs;
+	const result = summarizer.summarizeOnDemand(options);
 
 	const submitResult = await timeoutAwait(result.summarySubmitted);
 	if (!submitResult.success) {

package/src/index.ts

@@ -38,3 +38,4 @@ export {
 	TimeoutWithValue,
 } from "./timeoutUtils";
 export { waitForContainerConnection } from "./containerUtils";
+export { createContainerRuntimeFactoryWithDefaultDataStore } from "./testContainerRuntimeFactoryWithDefaultDataStore";

package/src/localCodeLoader.ts

@@ -71,13 +71,14 @@ export class LocalCodeLoader implements ICodeDetailsLoader {
 					fluidModule = {
 						fluidExport: {
 							...maybeExport,
-							IRuntimeFactory: new ContainerRuntimeFactoryWithDefaultDataStore(
+							IRuntimeFactory: new ContainerRuntimeFactoryWithDefaultDataStore({
 								defaultFactory,
-								[[defaultFactory.type, Promise.resolve(defaultFactory)]],
-								undefined,
-								[innerRequestHandler],
+								registryEntries: [
+									[defaultFactory.type, Promise.resolve(defaultFactory)],
+								],
+								requestHandlers: [innerRequestHandler],
 								runtimeOptions,
-							),
+							}),
 						},
 					};
 				}

package/src/packageVersion.ts

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

package/src/testContainerRuntimeFactory.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+// eslint-disable-next-line import/no-deprecated
 import { defaultRouteRequestHandler } from "@fluidframework/aqueduct";
 import { IContainerContext, IRuntime } from "@fluidframework/container-definitions";
 import {
@@ -11,6 +12,7 @@ import {
 	DefaultSummaryConfiguration,
 } from "@fluidframework/container-runtime";
 import { IContainerRuntime } from "@fluidframework/container-runtime-definitions";
+// eslint-disable-next-line import/no-deprecated
 import { buildRuntimeRequestHandler, RuntimeRequestHandler } from "@fluidframework/request-handler";
 import { IFluidDataStoreFactory } from "@fluidframework/runtime-definitions";
 import { RuntimeFactoryHelper } from "@fluidframework/runtime-utils";
@@ -52,8 +54,7 @@ export const createTestContainerRuntimeFactory = (
 		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.getAliasedDataStoreEntryPoint?.("default") ??
-				runtime.getRootDataStore("default"));
+			await runtime.getAliasedDataStoreEntryPoint("default");
 		}
 
 		async preInitialize(
@@ -66,7 +67,9 @@ export const createTestContainerRuntimeFactory = (
 					["default", Promise.resolve(this.dataStoreFactory)],
 					[this.type, Promise.resolve(this.dataStoreFactory)],
 				],
+				// eslint-disable-next-line import/no-deprecated
 				buildRuntimeRequestHandler(
+					// eslint-disable-next-line import/no-deprecated
 					defaultRouteRequestHandler("default"),
 					...this.requestHandlers,
 				),

package/src/testContainerRuntimeFactoryWithDefaultDataStore.ts

@@ -0,0 +1,50 @@
+/*!
+ * 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";
+
+/**
+ * ! Note: This function is purely needed for back-compat as the constructor argument structure was changed
+ */
+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,
+		} = ctorArgs;
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+		return new (Base as any)(
+			defaultFactory,
+			registryEntries,
+			dependencyContainer,
+			requestHandlers,
+			runtimeOptions,
+		);
+	}
+};

package/src/testFluidObject.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+// eslint-disable-next-line import/no-deprecated
 import { defaultFluidObjectRequestHandler } from "@fluidframework/aqueduct";
 import {
 	IRequest,
@@ -94,6 +95,7 @@ export class TestFluidObject implements ITestFluidObject {
 	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
 	 */
 	public async request(request: IRequest): Promise<IResponse> {
+		// eslint-disable-next-line import/no-deprecated
 		return defaultFluidObjectRequestHandler(this, request);
 	}
 
@@ -134,6 +136,7 @@ export type ChannelFactoryRegistry = Iterable<[string | undefined, IChannelFacto
  * Fluid object so that it can create a shared object for each.
  *
  * @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.
  *
@@ -152,7 +155,7 @@ export type ChannelFactoryRegistry = Iterable<[string | undefined, IChannelFacto
  * sharedDir = testFluidObject.getSharedObject<SharedDirectory>("sharedDirectory");
  * ```
  *
- * @privateRemarks - Beware that using this class generally forfeits some compatibility coverage
+ * @privateRemarks Beware that using this class generally forfeits some compatibility coverage
  * `describeCompat` aims to provide:
  * `SharedMap`s always reference the current version of SharedMap.
  * AB#4670 tracks improving this situation.
@@ -199,10 +202,9 @@ export class TestFluidObjectFactory implements IFluidDataStoreFactory {
 
 		const runtimeClass = mixinRequestHandler(
 			async (request: IRequest, rt: FluidDataStoreRuntime) => {
-				const maybeRouter: FluidObject<IProvideFluidRouter> | undefined =
-					await rt.entryPoint?.get();
+				const maybeRouter: FluidObject<IProvideFluidRouter> = await rt.entryPoint.get();
 				assert(
-					maybeRouter?.IFluidRouter !== undefined,
+					maybeRouter.IFluidRouter !== undefined,
 					"entryPoint should have been initialized by now",
 				);
 				return maybeRouter.IFluidRouter.request(request);

package/src/testObjectProvider.ts

@@ -7,7 +7,6 @@ import {
 	IContainer,
 	IHostLoader,
 	IFluidCodeDetails,
-	LoaderHeader,
 	ILoader,
 } from "@fluidframework/container-definitions";
 import {
@@ -112,9 +111,6 @@ export interface ITestContainerConfig {
 
 	/** Loader options for the loader used to create containers */
 	loaderProps?: Partial<ILoaderProps>;
-
-	/** Temporary flag: simulate read connection using delay connection, default is true */
-	simulateReadConnectionUsingDelay?: boolean;
 }
 
 export const createDocumentId = (): string => uuid();
@@ -386,41 +382,11 @@ export class TestObjectProvider implements ITestObjectProvider {
 		return this.resolveContainer(loader, requestHeader);
 	}
 
-	private async resolveContainer(
-		loader: ILoader,
-		requestHeader?: IRequestHeader,
-		delay: boolean = true,
-	) {
-		// Once AB#3889 is done to switch default connection mode to "read" on load, we don't need
-		// to load "delayed" across the board. Remove the following code.
-		const delayConnection =
-			delay &&
-			(requestHeader === undefined || requestHeader[LoaderHeader.reconnect] !== false);
-		const headers: IRequestHeader | undefined = delayConnection
-			? {
-					[LoaderHeader.loadMode]: { deltaConnection: "delayed" },
-					...requestHeader,
-			  }
-			: requestHeader;
-
-		const container = await loader.resolve({
+	private async resolveContainer(loader: ILoader, headers?: IRequestHeader) {
+		return loader.resolve({
 			url: await this.driver.createContainerUrl(this.documentId),
 			headers,
 		});
-
-		// Once AB#3889 is done to switch default connection mode to "read" on load, we don't need
-		// to load "delayed" across the board. Remove the following code.
-		if (delayConnection) {
-			// Older version may not have connect/disconnect. It was add in PR#9439, and available >= 0.59.1000
-			const maybeContainer = container as Partial<IContainer>;
-			if (maybeContainer.connect !== undefined) {
-				container.connect();
-			} else {
-				// back compat. Remove when we don't support < 0.59.1000
-				(container as any).resume();
-			}
-		}
-		return container;
 	}
 
 	/**
@@ -473,11 +439,7 @@ export class TestObjectProvider implements ITestObjectProvider {
 	): Promise<IContainer> {
 		const loader = this.makeTestLoader(testContainerConfig);
 
-		const container = await this.resolveContainer(
-			loader,
-			requestHeader,
-			testContainerConfig?.simulateReadConnectionUsingDelay,
-		);
+		const container = await this.resolveContainer(loader, requestHeader);
 		await this.waitContainerToCatchUp(container);
 
 		return container;