@fluidframework/test-utils 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/src/DriverWrappers.ts

@@ -5,11 +5,11 @@
 
 import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
 import {
-    IDocumentService,
-    IDocumentServiceFactory,
-    IDocumentStorageService,
-    IResolvedUrl,
-    ISummaryContext,
+	IDocumentService,
+	IDocumentServiceFactory,
+	IDocumentStorageService,
+	IResolvedUrl,
+	ISummaryContext,
 } from "@fluidframework/driver-definitions";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
 
@@ -19,18 +19,18 @@ import { ISummaryTree } from "@fluidframework/protocol-definitions";
  * callback before it is uploaded to the server.
  */
 export function wrapDocumentStorageService(
-    innerDocStorageService: IDocumentStorageService,
-    uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext,
+	innerDocStorageService: IDocumentStorageService,
+	uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext,
 ) {
-    const outerDocStorageService = Object.create(innerDocStorageService) as IDocumentStorageService;
-    outerDocStorageService.uploadSummaryWithContext = async (
-        summary: ISummaryTree,
-        context: ISummaryContext,
-    ): Promise<string> => {
-        const newContext = uploadSummaryCb(summary, context);
-        return innerDocStorageService.uploadSummaryWithContext(summary, newContext);
-    };
-    return outerDocStorageService;
+	const outerDocStorageService = Object.create(innerDocStorageService) as IDocumentStorageService;
+	outerDocStorageService.uploadSummaryWithContext = async (
+		summary: ISummaryTree,
+		context: ISummaryContext,
+	): Promise<string> => {
+		const newContext = uploadSummaryCb(summary, context);
+		return innerDocStorageService.uploadSummaryWithContext(summary, newContext);
+	};
+	return outerDocStorageService;
 }
 
 /**
@@ -41,15 +41,15 @@ export function wrapDocumentStorageService(
  * to pass in the `uploadSummaryCb`.
  */
 export function wrapDocumentService(
-    innerDocService: IDocumentService,
-    uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext,
+	innerDocService: IDocumentService,
+	uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext,
 ) {
-    const outerDocService = Object.create(innerDocService) as IDocumentService;
-    outerDocService.connectToStorage = async (): Promise<IDocumentStorageService> => {
-        const storageService = await innerDocService.connectToStorage();
-        return wrapDocumentStorageService(storageService, uploadSummaryCb);
-    };
-    return outerDocService;
+	const outerDocService = Object.create(innerDocService) as IDocumentService;
+	outerDocService.connectToStorage = async (): Promise<IDocumentStorageService> => {
+		const storageService = await innerDocService.connectToStorage();
+		return wrapDocumentStorageService(storageService, uploadSummaryCb);
+	};
+	return outerDocService;
 }
 
 /**
@@ -60,18 +60,21 @@ export function wrapDocumentService(
  * pass in the `uploadSummaryCb`.
  */
 export function wrapDocumentServiceFactory(
-    innerDocServiceFactory: IDocumentServiceFactory,
-    uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext,
+	innerDocServiceFactory: IDocumentServiceFactory,
+	uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext,
 ) {
-    const outerDocServiceFactory = Object.create(innerDocServiceFactory) as IDocumentServiceFactory;
-    outerDocServiceFactory.createDocumentService = async (
-        resolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> => {
-        const documentService = await innerDocServiceFactory.createDocumentService(
-            resolvedUrl, logger, clientIsSummarizer);
-        return wrapDocumentService(documentService, uploadSummaryCb);
-    };
-    return outerDocServiceFactory;
+	const outerDocServiceFactory = Object.create(innerDocServiceFactory) as IDocumentServiceFactory;
+	outerDocServiceFactory.createDocumentService = async (
+		resolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> => {
+		const documentService = await innerDocServiceFactory.createDocumentService(
+			resolvedUrl,
+			logger,
+			clientIsSummarizer,
+		);
+		return wrapDocumentService(documentService, uploadSummaryCb);
+	};
+	return outerDocServiceFactory;
 }

package/src/TestConfigs.ts

@@ -5,10 +5,12 @@
 
 import { ConfigTypes, IConfigProviderBase } from "@fluidframework/telemetry-utils";
 
-export const mockConfigProvider = ((settings: Record<string, ConfigTypes> = {}): IConfigProviderBase => {
-    settings["Fluid.GarbageCollection.TrackGCState"] = "true";
-    settings["Fluid.GarbageCollection.WriteDataAtRoot"] = "true";
-    return {
-        getRawConfig: (name: string): ConfigTypes => settings[name],
-    };
-});
+export const mockConfigProvider = (
+	settings: Record<string, ConfigTypes> = {},
+): IConfigProviderBase => {
+	settings["Fluid.GarbageCollection.TrackGCState"] = "true";
+	settings["Fluid.GarbageCollection.WriteDataAtRoot"] = "true";
+	return {
+		getRawConfig: (name: string): ConfigTypes => settings[name],
+	};
+};

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,131 @@ 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(
+	container: IContainer,
+	loader: IHostLoader,
+	summaryVersion?: string,
+) {
+	const absoluteUrl = await container.getAbsoluteUrl("");
+	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,
+	},
 };
 
+/**
+ * Creates a summarizer client from the given container and data store factory, and returns the summarizer client's
+ * IContainer and ISummarizer.
+ * The ISummarizer can be used to generate on-demand summaries. The IContainer can be used to fetch data stores, etc.
+ */
 export async function createSummarizerFromFactory(
-    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;
+	provider: ITestObjectProvider,
+	container: IContainer,
+	dataStoreFactory: IFluidDataStoreFactory,
+	summaryVersion?: string,
+	containerRuntimeFactoryType = ContainerRuntimeFactoryWithDefaultDataStore,
+	registryEntries?: NamedFluidDataStoreRegistryEntries,
+): 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 loader = provider.createLoader([[provider.defaultCodeDetails, runtimeFactory]], {
+		configProvider: mockConfigProvider(),
+	});
+	return createSummarizerCore(container, loader, summaryVersion);
 }
 
+/**
+ * Creates a summarizer client from the given container and returns the summarizer client's IContainer and ISummarizer.
+ * The ISummarizer can be used to generate on-demand summaries. The IContainer can be used to fetch data stores, etc.
+ */
 export async function createSummarizer(
-    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;
+	provider: ITestObjectProvider,
+	container: IContainer,
+	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(container, loader, summaryVersion);
 }
 
-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);
-}
 /**
  * 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

@@ -4,7 +4,7 @@
  */
 
 import { IContainer } from "@fluidframework/container-definitions";
-import { ConnectionState, Container } from "@fluidframework/container-loader";
+import { ConnectionState } from "@fluidframework/container-loader";
 import { PromiseExecutor, timeoutPromise, TimeoutWithError } from "./timeoutUtils";
 
 /**
@@ -15,10 +15,10 @@ import { PromiseExecutor, timeoutPromise, TimeoutWithError } from "./timeoutUtil
  * - failOnContainerClose = true
  * - timeoutOptions.durationMs = 1s
  */
-export async function ensureContainerConnected(container: Container): Promise<void> {
-    if (!container.connected) {
-        return timeoutPromise((resolve) => container.once("connected", () => resolve()));
-    }
+export async function ensureContainerConnected(container: IContainer): Promise<void> {
+	if (container.connectionState !== ConnectionState.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,38 @@
  * 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, summarizeNow } from "./TestSummaryUtils";
 export {
-    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>;
 }