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

package/src/TestSummaryUtils.ts

@@ -7,16 +7,16 @@ import { ContainerRuntimeFactoryWithDefaultDataStore } from "@fluidframework/aqu
 import { assert } from "@fluidframework/common-utils";
 import { IContainer, IHostLoader, LoaderHeader } from "@fluidframework/container-definitions";
 import {
-    IGCRuntimeOptions,
-    ISummarizer,
-    ISummaryRuntimeOptions,
+	IGCRuntimeOptions,
+	ISummarizer,
+	ISummaryRuntimeOptions,
 } from "@fluidframework/container-runtime";
 import { FluidObject, IRequest } from "@fluidframework/core-interfaces";
 import { DriverHeader } from "@fluidframework/driver-definitions";
 import {
-    IContainerRuntimeBase,
-    IFluidDataStoreFactory,
-    NamedFluidDataStoreRegistryEntries,
+	IContainerRuntimeBase,
+	IFluidDataStoreFactory,
+	NamedFluidDataStoreRegistryEntries,
 } from "@fluidframework/runtime-definitions";
 import { requestFluidObject } from "@fluidframework/runtime-utils";
 import { IConfigProviderBase } from "@fluidframework/telemetry-utils";
@@ -28,137 +28,142 @@ import { timeoutAwait } from "./timeoutUtils";
 
 const summarizerClientType = "summarizer";
 
-async function createSummarizerCore(absoluteUrl: string | undefined, loader: IHostLoader, summaryVersion?: string) {
-    if (absoluteUrl === undefined) {
-        throw new Error("URL could not be resolved");
-    }
-
-    const request: IRequest = {
-        headers: {
-            [LoaderHeader.cache]: false,
-            [LoaderHeader.clientDetails]: {
-                capabilities: { interactive: false },
-                type: summarizerClientType,
-            },
-            [DriverHeader.summarizingClient]: true,
-            [LoaderHeader.version]: summaryVersion,
-        },
-        url: absoluteUrl,
-    };
-    const summarizerContainer = await loader.resolve(request);
-    await waitForContainerConnection(summarizerContainer);
-
-    const fluidObject =
-        await requestFluidObject<FluidObject<ISummarizer>>(summarizerContainer, { url: "_summarizer" });
-    if (fluidObject.ISummarizer === undefined) {
-        throw new Error("Fluid object does not implement ISummarizer");
-    }
-
-    return {
-        container: summarizerContainer,
-        summarizer: fluidObject.ISummarizer,
-    };
+async function createSummarizerCore(
+	absoluteUrl: string | undefined,
+	loader: IHostLoader,
+	summaryVersion?: string,
+) {
+	if (absoluteUrl === undefined) {
+		throw new Error("URL could not be resolved");
+	}
+
+	const request: IRequest = {
+		headers: {
+			[LoaderHeader.cache]: false,
+			[LoaderHeader.clientDetails]: {
+				capabilities: { interactive: false },
+				type: summarizerClientType,
+			},
+			[DriverHeader.summarizingClient]: true,
+			[LoaderHeader.version]: summaryVersion,
+		},
+		url: absoluteUrl,
+	};
+	const summarizerContainer = await loader.resolve(request);
+	await waitForContainerConnection(summarizerContainer);
+
+	const fluidObject = await requestFluidObject<FluidObject<ISummarizer>>(summarizerContainer, {
+		url: "_summarizer",
+	});
+	if (fluidObject.ISummarizer === undefined) {
+		throw new Error("Fluid object does not implement ISummarizer");
+	}
+
+	return {
+		container: summarizerContainer,
+		summarizer: fluidObject.ISummarizer,
+	};
 }
 
 const defaultSummaryOptions: ISummaryRuntimeOptions = {
-    summaryConfigOverrides: {
-        state: "disableHeuristics",
-        maxAckWaitTime: 10000,
-        maxOpsSinceLastSummary: 7000,
-        initialSummarizerDelayMs: 0,
-    },
+	summaryConfigOverrides: {
+		state: "disableHeuristics",
+		maxAckWaitTime: 10000,
+		maxOpsSinceLastSummary: 7000,
+		initialSummarizerDelayMs: 0,
+	},
 };
 
 export async function createSummarizerFromFactory(
-    provider: ITestObjectProvider,
-    container: IContainer,
-    dataStoreFactory: IFluidDataStoreFactory,
-    summaryVersion?: string,
-    containerRuntimeFactoryType = ContainerRuntimeFactoryWithDefaultDataStore,
-    registryEntries?: NamedFluidDataStoreRegistryEntries,
+	provider: ITestObjectProvider,
+	container: IContainer,
+	dataStoreFactory: IFluidDataStoreFactory,
+	summaryVersion?: string,
+	containerRuntimeFactoryType = ContainerRuntimeFactoryWithDefaultDataStore,
+	registryEntries?: NamedFluidDataStoreRegistryEntries,
 ): Promise<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 loader = provider.createLoader(
-        [[provider.defaultCodeDetails, runtimeFactory]],
-        { configProvider: mockConfigProvider() },
-    );
-    const absoluteUrl = await container.getAbsoluteUrl("");
-    return (await createSummarizerCore(absoluteUrl, loader, summaryVersion)).summarizer;
+	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 loader = provider.createLoader([[provider.defaultCodeDetails, runtimeFactory]], {
+		configProvider: mockConfigProvider(),
+	});
+	const absoluteUrl = await container.getAbsoluteUrl("");
+	return (await createSummarizerCore(absoluteUrl, loader, summaryVersion)).summarizer;
 }
 
 export async function createSummarizer(
-    provider: ITestObjectProvider,
-    container: IContainer,
-    summaryVersion?: string,
-    gcOptions?: IGCRuntimeOptions,
-    configProvider: IConfigProviderBase = mockConfigProvider(),
-    logger?: ITelemetryBaseLogger,
+	provider: ITestObjectProvider,
+	container: IContainer,
+	summaryVersion?: string,
+	gcOptions?: IGCRuntimeOptions,
+	configProvider: IConfigProviderBase = mockConfigProvider(),
+	logger?: ITelemetryBaseLogger,
 ): Promise<ISummarizer> {
-    const absoluteUrl = await container.getAbsoluteUrl("");
-    return (await createSummarizerWithContainer(
-        provider,
-        absoluteUrl,
-        summaryVersion,
-        gcOptions,
-        configProvider,
-        logger,
-    )).summarizer;
+	const absoluteUrl = await container.getAbsoluteUrl("");
+	return (
+		await createSummarizerWithContainer(
+			provider,
+			absoluteUrl,
+			summaryVersion,
+			gcOptions,
+			configProvider,
+			logger,
+		)
+	).summarizer;
 }
 
 export async function createSummarizerWithContainer(
-    provider: ITestObjectProvider,
-    absoluteUrl: string | undefined,
-    summaryVersion?: string,
-    gcOptions?: IGCRuntimeOptions,
-    configProvider: IConfigProviderBase = mockConfigProvider(),
-    logger?: ITelemetryBaseLogger,
-): Promise<{ container: IContainer; summarizer: ISummarizer; }> {
-    const testContainerConfig: ITestContainerConfig = {
-        runtimeOptions: {
-            summaryOptions: defaultSummaryOptions,
-            gcOptions,
-        },
-        loaderProps: { configProvider, logger },
-    };
-    const loader = provider.makeTestLoader(testContainerConfig);
-    return createSummarizerCore(absoluteUrl, loader, summaryVersion);
+	provider: ITestObjectProvider,
+	absoluteUrl: string | undefined,
+	summaryVersion?: string,
+	gcOptions?: IGCRuntimeOptions,
+	configProvider: IConfigProviderBase = mockConfigProvider(),
+	logger?: ITelemetryBaseLogger,
+): Promise<{ container: IContainer; summarizer: ISummarizer }> {
+	const testContainerConfig: ITestContainerConfig = {
+		runtimeOptions: {
+			summaryOptions: defaultSummaryOptions,
+			gcOptions,
+		},
+		loaderProps: { configProvider, logger },
+	};
+	const loader = provider.makeTestLoader(testContainerConfig);
+	return createSummarizerCore(absoluteUrl, loader, summaryVersion);
 }
 /**
  * Summarizes on demand and returns the summary tree, the version number and the reference sequence number of the
  * submitted summary.
-*/
+ */
 export async function summarizeNow(summarizer: ISummarizer, reason: string = "end-to-end test") {
-    const result = summarizer.summarizeOnDemand({ reason });
+	const result = summarizer.summarizeOnDemand({ reason });
 
-    const submitResult = await timeoutAwait(result.summarySubmitted);
-    assert(submitResult.success, "on-demand summary should submit");
-    assert(submitResult.data.stage === "submit",
-        "on-demand summary submitted data stage should be submit");
-    assert(submitResult.data.summaryTree !== undefined, "summary tree should exist");
+	const submitResult = await timeoutAwait(result.summarySubmitted);
+	assert(submitResult.success, "on-demand summary should submit");
+	assert(
+		submitResult.data.stage === "submit",
+		"on-demand summary submitted data stage should be submit",
+	);
+	assert(submitResult.data.summaryTree !== undefined, "summary tree should exist");
 
-    const broadcastResult = await timeoutAwait(result.summaryOpBroadcasted);
-    assert(broadcastResult.success, "summary op should be broadcast");
+	const broadcastResult = await timeoutAwait(result.summaryOpBroadcasted);
+	assert(broadcastResult.success, "summary op should be broadcast");
 
-    const ackNackResult = await timeoutAwait(result.receivedSummaryAckOrNack);
-    assert(ackNackResult.success, "summary op should be acked");
+	const ackNackResult = await timeoutAwait(result.receivedSummaryAckOrNack);
+	assert(ackNackResult.success, "summary op should be acked");
 
-    await new Promise((resolve) => process.nextTick(resolve));
+	await new Promise((resolve) => process.nextTick(resolve));
 
-    return {
-        summaryTree: submitResult.data.summaryTree,
-        summaryVersion: ackNackResult.data.summaryAckOp.contents.handle,
-        summaryRefSeq: submitResult.data.referenceSequenceNumber,
-    };
+	return {
+		summaryTree: submitResult.data.summaryTree,
+		summaryVersion: ackNackResult.data.summaryAckOp.contents.handle,
+		summaryRefSeq: submitResult.data.referenceSequenceNumber,
+	};
 }

package/src/containerUtils.ts

@@ -16,9 +16,9 @@ import { PromiseExecutor, timeoutPromise, TimeoutWithError } from "./timeoutUtil
  * - timeoutOptions.durationMs = 1s
  */
 export async function ensureContainerConnected(container: Container): Promise<void> {
-    if (!container.connected) {
-        return timeoutPromise((resolve) => container.once("connected", () => resolve()));
-    }
+	if (!container.connected) {
+		return timeoutPromise((resolve) => container.once("connected", () => resolve()));
+	}
 }
 
 /**
@@ -42,18 +42,20 @@ export async function ensureContainerConnected(container: Container): Promise<vo
  * timeoutOptions.durationMs (which defaults to 250ms if left undefined).
  */
 export async function waitForContainerConnection(
-    container: IContainer,
-    failOnContainerClose: boolean = false,
-    timeoutOptions?: TimeoutWithError): Promise<void> {
-    if (container.connectionState !== ConnectionState.Connected) {
+	container: IContainer,
+	failOnContainerClose: boolean = false,
+	timeoutOptions?: TimeoutWithError,
+): Promise<void> {
+	if (container.connectionState !== ConnectionState.Connected) {
+		const executor: PromiseExecutor = (resolve, reject) => {
+			container.once("connected", () => resolve());
+			if (failOnContainerClose) {
+				container.once("closed", (error) => reject(error));
+			}
+		};
 
-        const executor: PromiseExecutor = (resolve, reject) => {
-            container.once("connected", () => resolve())
-            if (failOnContainerClose) {
-                container.once("closed", (error) =>  reject(error));
-            }
-        };
-
-        return timeoutOptions === undefined ? new Promise(executor) : timeoutPromise(executor, timeoutOptions);
-    }
+		return timeoutOptions === undefined
+			? new Promise(executor)
+			: timeoutPromise(executor, timeoutOptions);
+	}
 }

package/src/index.ts

@@ -3,39 +3,43 @@
  * Licensed under the MIT License.
  */
 
-export { wrapDocumentService, wrapDocumentServiceFactory, wrapDocumentStorageService } from "./DriverWrappers";
+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";
-export { createTestContainerRuntimeFactory, TestContainerRuntimeFactory } from "./testContainerRuntimeFactory";
+export {
+	createTestContainerRuntimeFactory,
+	TestContainerRuntimeFactory,
+} from "./testContainerRuntimeFactory";
 export { ChannelFactoryRegistry, TestFluidObject, TestFluidObjectFactory } from "./testFluidObject";
 export {
-    createDocumentId,
-    DataObjectFactoryType,
-    EventAndErrorTrackingLogger,
-    getUnexpectedLogErrorException,
-    IOpProcessingController,
-    ITestContainerConfig,
-    ITestObjectProvider,
-    TestObjectProvider,
+	createDocumentId,
+	DataObjectFactoryType,
+	EventAndErrorTrackingLogger,
+	getUnexpectedLogErrorException,
+	IOpProcessingController,
+	ITestContainerConfig,
+	ITestObjectProvider,
+	TestObjectProvider,
 } from "./testObjectProvider";
 export {
-    createSummarizer,
-    createSummarizerFromFactory,
-    createSummarizerWithContainer,
-    summarizeNow,
+	createSummarizer,
+	createSummarizerFromFactory,
+	createSummarizerWithContainer,
+	summarizeNow,
 } from "./TestSummaryUtils";
 export {
-    defaultTimeoutDurationMs,
-    timeoutAwait,
-    timeoutPromise,
-    TimeoutWithError,
-    TimeoutWithValue,
+	defaultTimeoutDurationMs,
+	timeoutAwait,
+	timeoutPromise,
+	TimeoutWithError,
+	TimeoutWithValue,
 } from "./timeoutUtils";
-export {
-    ensureContainerConnected,
-    waitForContainerConnection,
-} from "./containerUtils";
+export { ensureContainerConnected, waitForContainerConnection } from "./containerUtils";

package/src/interfaces.ts

@@ -5,17 +5,20 @@
 
 import { IFluidDataStoreRuntime } from "@fluidframework/datastore-definitions";
 import { ISharedMap } from "@fluidframework/map";
-import { IFluidDataStoreContext, IFluidDataStoreChannel } from "@fluidframework/runtime-definitions";
+import {
+	IFluidDataStoreContext,
+	IFluidDataStoreChannel,
+} from "@fluidframework/runtime-definitions";
 import { IFluidLoadable } from "@fluidframework/core-interfaces";
 
 export interface IProvideTestFluidObject {
-    readonly ITestFluidObject: ITestFluidObject;
+	readonly ITestFluidObject: ITestFluidObject;
 }
 
 export interface ITestFluidObject extends IProvideTestFluidObject, IFluidLoadable {
-    root: ISharedMap;
-    readonly runtime: IFluidDataStoreRuntime;
-    readonly channel: IFluidDataStoreChannel;
-    readonly context: IFluidDataStoreContext;
-    getSharedObject<T = any>(id: string): Promise<T>;
+	root: ISharedMap;
+	readonly runtime: IFluidDataStoreRuntime;
+	readonly channel: IFluidDataStoreChannel;
+	readonly context: IFluidDataStoreContext;
+	getSharedObject<T = any>(id: string): Promise<T>;
 }