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

package/dist/test-utils-public.d.ts

@@ -0,0 +1,675 @@
+import { ConfigTypes } from '@fluidframework/telemetry-utils';
+import { ContainerRuntime } from '@fluidframework/container-runtime';
+import { ContainerRuntimeFactoryWithDefaultDataStore } from '@fluidframework/aqueduct';
+import { FluidDataStoreRuntime } from '@fluidframework/datastore';
+import { FluidObject } from '@fluidframework/core-interfaces';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { ICodeDetailsLoader } from '@fluidframework/container-definitions';
+import { IConfigProviderBase } from '@fluidframework/telemetry-utils';
+import { IContainer } from '@fluidframework/container-definitions';
+import { IContainerContext } from '@fluidframework/container-definitions';
+import { IContainerRuntime } from '@fluidframework/container-runtime-definitions';
+import { IContainerRuntimeOptions } from '@fluidframework/container-runtime';
+import { IDocumentService } from '@fluidframework/driver-definitions';
+import { IDocumentServiceFactory } from '@fluidframework/driver-definitions';
+import { IDocumentStorageService } from '@fluidframework/driver-definitions';
+import { IFluidCodeDetails } from '@fluidframework/container-definitions';
+import { IFluidDataStoreChannel } from '@fluidframework/runtime-definitions';
+import { IFluidDataStoreContext } from '@fluidframework/runtime-definitions';
+import { IFluidDataStoreFactory } from '@fluidframework/runtime-definitions';
+import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
+import { IFluidHandle } from '@fluidframework/core-interfaces';
+import { IFluidLoadable } from '@fluidframework/core-interfaces';
+import { IFluidModule } from '@fluidframework/container-definitions';
+import { IFluidModuleWithDetails } from '@fluidframework/container-definitions';
+import { IHostLoader } from '@fluidframework/container-definitions';
+import { ILoaderOptions } from '@fluidframework/container-definitions';
+import { ILoaderProps } from '@fluidframework/container-loader';
+import { IOnDemandSummarizeOptions } from '@fluidframework/container-runtime';
+import { IProvideFluidCodeDetailsComparer } from '@fluidframework/container-definitions';
+import { IProvideFluidDataStoreFactory } from '@fluidframework/runtime-definitions';
+import { IProvideFluidDataStoreRegistry } from '@fluidframework/runtime-definitions';
+import { IProvideRuntimeFactory } from '@fluidframework/container-definitions';
+import { IRequest } from '@fluidframework/core-interfaces';
+import { IRequestHeader } from '@fluidframework/core-interfaces';
+import { IResolvedUrl } from '@fluidframework/driver-definitions';
+import { IResponse } from '@fluidframework/core-interfaces';
+import { IRuntime } from '@fluidframework/container-definitions';
+import { ISharedMap } from '@fluidframework/map';
+import { ISummarizer } from '@fluidframework/container-runtime';
+import { ISummaryContext } from '@fluidframework/driver-definitions';
+import { ISummaryTree } from '@fluidframework/protocol-definitions';
+import { ITelemetryBaseEvent } from '@fluidframework/core-interfaces';
+import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
+import { ITelemetryGenericEvent } from '@fluidframework/core-interfaces';
+import { ITestDriver } from '@fluidframework/test-driver-definitions';
+import { IUrlResolver } from '@fluidframework/driver-definitions';
+import { Loader } from '@fluidframework/container-loader';
+import { NamedFluidDataStoreRegistryEntries } from '@fluidframework/runtime-definitions';
+import { RuntimeRequestHandler } from '@fluidframework/request-handler';
+
+export declare type ChannelFactoryRegistry = Iterable<[string | undefined, IChannelFactory]>;
+
+/**
+ * Creates a detached Container and attaches it.
+ * @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.
+ */
+export declare function createAndAttachContainer(source: IFluidCodeDetails, loader: IHostLoader, attachRequest: IRequest): Promise<IContainer>;
+
+/**
+ * ! Note: This function is purely needed for back-compat as the constructor argument structure was changed
+ */
+export declare const createContainerRuntimeFactoryWithDefaultDataStore: (Base: typeof ContainerRuntimeFactoryWithDefaultDataStore | undefined, ctorArgs: {
+    defaultFactory: IFluidDataStoreFactory;
+    registryEntries: NamedFluidDataStoreRegistryEntries;
+    dependencyContainer?: any;
+    requestHandlers?: RuntimeRequestHandler[] | undefined;
+    runtimeOptions?: IContainerRuntimeOptions | undefined;
+    provideEntryPoint?: ((runtime: IContainerRuntime) => Promise<FluidObject>) | undefined;
+}) => ContainerRuntimeFactoryWithDefaultDataStore;
+
+export declare const createDocumentId: () => string;
+
+/**
+ * Creates a loader with the given package entries and driver.
+ * @param packageEntries - A list of code details to Fluid entry points.
+ * @param documentServiceFactory - the driver factory to use
+ * @param urlResolver - the url resolver to use
+ * @param options - loader options
+ */
+export declare function createLoader(packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>, documentServiceFactory: IDocumentServiceFactory, urlResolver: IUrlResolver, logger?: ITelemetryBaseLogger, options?: ILoaderOptions): IHostLoader;
+
+/**
+ * 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.
+ *
+ * Can pass in a test config provider to enable/disable features.
+ */
+export declare function createSummarizer(provider: ITestObjectProvider, container: IContainer, config?: ITestContainerConfig, summaryVersion?: string, logger?: ITelemetryBaseLogger): Promise<{
+    container: IContainer;
+    summarizer: ISummarizer;
+}>;
+
+/**
+ * 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 declare function createSummarizerFromFactory(provider: ITestObjectProvider, container: IContainer, dataStoreFactory: IFluidDataStoreFactory, summaryVersion?: string, containerRuntimeFactoryType?: typeof ContainerRuntimeFactoryWithDefaultDataStore, registryEntries?: NamedFluidDataStoreRegistryEntries, logger?: ITelemetryBaseLogger, configProvider?: IConfigProviderBase): Promise<{
+    container: IContainer;
+    summarizer: ISummarizer;
+}>;
+
+/**
+ * Create a container runtime factory class that allows you to set runtime options
+ */
+export declare const createTestContainerRuntimeFactory: (containerRuntimeCtor: typeof ContainerRuntime) => {
+    new (type: string, dataStoreFactory: IFluidDataStoreFactory, runtimeOptions?: IContainerRuntimeOptions, requestHandlers?: RuntimeRequestHandler[]): {
+        type: string;
+        dataStoreFactory: IFluidDataStoreFactory;
+        runtimeOptions: IContainerRuntimeOptions;
+        requestHandlers: RuntimeRequestHandler[];
+        instantiateFirstTime(runtime: ContainerRuntime): Promise<void>;
+        instantiateFromExisting(runtime: ContainerRuntime): Promise<void>;
+        preInitialize(context: IContainerContext, existing: boolean): Promise<IRuntime & IContainerRuntime>;
+        readonly IRuntimeFactory: any;
+        instantiateRuntime(context: IContainerContext, existing: boolean): Promise<IRuntime>;
+        hasInitialized(_runtime: IContainerRuntime): Promise<void>;
+    };
+};
+
+export declare enum DataObjectFactoryType {
+    Primed = 0,
+    Test = 1
+}
+
+export declare const defaultTimeoutDurationMs = 250;
+
+/**
+ * This class tracks events. It allows specifying expected events, which will be looked for in order.
+ * It also tracks all unexpected errors.
+ * At any point you call reportAndClearTrackedEvents which will provide all unexpected errors, and
+ * any expected events that have not occurred.
+ */
+export declare class EventAndErrorTrackingLogger implements ITelemetryBaseLogger {
+    private readonly baseLogger;
+    /**
+     * Even if these error events are logged, tests should still be allowed to pass
+     * Additionally, if downgrade is true, then log as generic (e.g. to avoid polluting the e2e test logs)
+     */
+    private readonly allowedErrors;
+    constructor(baseLogger: ITelemetryBaseLogger);
+    private readonly expectedEvents;
+    private readonly unexpectedErrors;
+    registerExpectedEvent(...orderedExpectedEvents: ITelemetryGenericEvent[]): void;
+    send(event: ITelemetryBaseEvent): void;
+    reportAndClearTrackedEvents(): {
+        expectedNotFound: ({
+            index: number;
+            event: ITelemetryGenericEvent | undefined;
+        } | undefined)[];
+        unexpectedErrors: ITelemetryBaseEvent[];
+    };
+}
+
+export declare type fluidEntryPoint = SupportedExportInterfaces | IFluidModule;
+
+export declare function getUnexpectedLogErrorException(logger: EventAndErrorTrackingLogger | undefined, prefix?: string): Error | undefined;
+
+export declare interface IOpProcessingController {
+    processIncoming(...containers: IContainer[]): Promise<void>;
+    processOutgoing(...containers: IContainer[]): Promise<void>;
+    pauseProcessing(...containers: IContainer[]): Promise<void>;
+    resumeProcessing(...containers: IContainer[]): void;
+}
+
+export declare interface IProvideTestFluidObject {
+    readonly ITestFluidObject: ITestFluidObject;
+}
+
+export declare interface ITestContainerConfig {
+    /** TestFluidDataObject instead of PrimedDataStore */
+    fluidDataObjectType?: DataObjectFactoryType;
+    /** An array of channel name and DDS factory pair to create on container creation time */
+    registry?: ChannelFactoryRegistry;
+    /** Container runtime options for the container instance */
+    runtimeOptions?: IContainerRuntimeOptions;
+    /** Whether this runtime should be instantiated using a mixed-in attributor class */
+    enableAttribution?: boolean;
+    /** Loader options for the loader used to create containers */
+    loaderProps?: Partial<ILoaderProps>;
+}
+
+export declare interface ITestFluidObject extends IProvideTestFluidObject, IFluidLoadable {
+    root: ISharedMap;
+    readonly runtime: IFluidDataStoreRuntime;
+    readonly channel: IFluidDataStoreChannel;
+    readonly context: IFluidDataStoreContext;
+    getSharedObject<T = any>(id: string): Promise<T>;
+}
+
+export declare interface ITestObjectProvider {
+    createFluidEntryPoint: (testContainerConfig?: ITestContainerConfig) => fluidEntryPoint;
+    createLoader(packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>, loaderProps?: Partial<ILoaderProps>): IHostLoader;
+    createContainer(entryPoint: fluidEntryPoint, loaderProps?: Partial<ILoaderProps>): Promise<IContainer>;
+    loadContainer(entryPoint: fluidEntryPoint, loaderProps?: Partial<ILoaderProps>, requestHeader?: IRequestHeader): Promise<IContainer>;
+    /**
+     * Used to create a test Container. The Loader/ContainerRuntime/DataRuntime might be different versioned.
+     * In generateLocalCompatTest(), this Container and its runtime will be arbitrarily-versioned.
+     */
+    makeTestLoader(testContainerConfig?: ITestContainerConfig): IHostLoader;
+    makeTestContainer(testContainerConfig?: ITestContainerConfig): Promise<IContainer>;
+    loadTestContainer(testContainerConfig?: ITestContainerConfig, requestHeader?: IRequestHeader): Promise<IContainer>;
+    /**
+     *
+     * @param url - Resolved container URL
+     */
+    updateDocumentId(url: IResolvedUrl | undefined): void;
+    logger: ITelemetryBaseLogger;
+    documentServiceFactory: IDocumentServiceFactory;
+    urlResolver: IUrlResolver;
+    defaultCodeDetails: IFluidCodeDetails;
+    opProcessingController: IOpProcessingController;
+    ensureSynchronized(timeoutDuration?: number): Promise<void>;
+    reset(): void;
+    documentId: string;
+    driver: ITestDriver;
+}
+
+export declare class LoaderContainerTracker implements IOpProcessingController {
+    private readonly syncSummarizerClients;
+    private readonly containers;
+    private lastProposalSeqNum;
+    constructor(syncSummarizerClients?: boolean);
+    /**
+     * Add a loader to start to track any container created from them
+     * @param loader - loader to start tracking any container created.
+     */
+    add<LoaderType extends IHostLoader>(loader: LoaderType): void;
+    /**
+     * Utility function to add container to be tracked.
+     *
+     * @param container - container to add
+     */
+    private addContainer;
+    /**
+     * Keep track of the trailing NoOp that was sent so we can discount them in the clientSequenceNumber tracking.
+     * The server might coalesce them with other ops, or a single NoOp, or delay it if it don't think it is necessary.
+     *
+     * @param container - the container to track
+     * @param record - the record to update the trailing op information
+     */
+    private trackTrailingNoOps;
+    private trackLastProposal;
+    /**
+     * Reset the tracker, closing all containers and stop tracking them.
+     */
+    reset(): void;
+    /**
+     * Make sure all the tracked containers are synchronized.
+     *
+     * No isDirty (non-readonly) containers
+     * No extra clientId in quorum of any container that is not tracked and still opened.
+     * - i.e. no pending Join/Leave message.
+     * No unresolved proposal (minSeqNum \>= lastProposalSeqNum)
+     * lastSequenceNumber of all container is the same
+     * clientSequenceNumberObserved is the same as clientSequenceNumber sent
+     * - this overlaps with !isDirty, but include task scheduler ops.
+     * - Trailing NoOp is tracked and don't count as pending ops.
+     *
+     * Containers that are already pause will resume process and paused again once
+     * everything is synchronized.  Containers that aren't paused will remain unpaused when this
+     * function returns.
+     */
+    ensureSynchronized(...containers: IContainer[]): Promise<void>;
+    /**
+     * Utility to calculate the set of clientId per container in quorum that is NOT associated with
+     * any container we tracked, indicating there is a pending join or leave op that we need to wait.
+     *
+     * @param containersToApply - the set of containers to check
+     */
+    private getPendingClients;
+    /**
+     * Utility to check synchronization based on sequence number
+     * See ensureSynchronized for more detail
+     *
+     * @param containersToApply - the set of containers to check
+     */
+    private needSequenceNumberSynchronize;
+    private containerIndexStrings;
+    /**
+     * Utility to wait for any clientId in quorum that is NOT associated with any container we
+     * tracked, indicating there is a pending join or leave op that we need to wait.
+     *
+     * Note that this function doesn't account for container that got added after we started waiting
+     *
+     * @param containersToApply - the set of containers to wait for any inbound ops for
+     */
+    private waitForPendingClients;
+    /**
+     * Utility to wait for any inbound ops from a set of containers
+     * @param containersToApply - the set of containers to wait for any inbound ops for
+     */
+    private waitForAnyInboundOps;
+    /**
+     * Resume all queue activities on all paused tracked containers and return them
+     */
+    resumeProcessing(...containers: IContainer[]): IContainer[];
+    /**
+     * Pause all queue activities on the containers given, or all tracked containers
+     * Any containers given that is not tracked will be ignored.
+     *
+     * When a container is paused, it is assumed that we want fine grain control over op
+     * sequencing.  This function will prepare the container and force it into write mode to
+     * avoid missing join messages or change the sequence of event when switching from read to
+     * write mode.
+     */
+    pauseProcessing(...containers: IContainer[]): Promise<void>;
+    /**
+     * When a container is paused, it is assumed that we want fine grain control over op
+     * sequencing.  This function will prepare the container and force it into write mode to
+     * avoid missing join messages or change the sequence of event when switching from read to
+     * write mode.
+     *
+     * @param container - the container to pause
+     * @param record - the record for the container
+     */
+    private pauseContainer;
+    /**
+     * Pause all queue activities on all tracked containers, and resume only
+     * inbound to process ops until it is idle. All queues are left in the paused state
+     * after the function.
+     *
+     * Pausing will switch the container to write mode. See `pauseProcessing`
+     */
+    processIncoming(...containers: IContainer[]): Promise<void>;
+    /**
+     * Pause all queue activities on all tracked containers, and resume only
+     * outbound to process ops until it is idle. All queues are left in the paused state
+     * after the function.
+     *
+     * Pausing will switch the container to write mode. See `pauseProcessing`
+     */
+    processOutgoing(...containers: IContainer[]): Promise<void>;
+    /**
+     * Implementation of processIncoming and processOutgoing
+     */
+    private processQueue;
+    /**
+     * Utility to set up listener to track the outbound ops until it round trip back
+     * Returns a function to remove the handler after it is done.
+     *
+     * @param container - the container to setup
+     * @param inflightTracker - a map to track the clientSequenceNumber per container it expect to get ops back
+     */
+    private setupInOutTracker;
+    /**
+     * Setup debug traces for connection and ops
+     */
+    private setupTrace;
+    /**
+     * Filter out the opened containers based on param.
+     * @param containers - The container to filter to.  If the array is empty, it means don't filter and return
+     * all open containers.
+     */
+    private getContainers;
+}
+
+/**
+ * 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.
+ */
+export declare class LocalCodeLoader implements ICodeDetailsLoader {
+    private readonly fluidPackageCache;
+    constructor(packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>, runtimeOptions?: IContainerRuntimeOptions);
+    /**
+     * 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
+     */
+    load(source: IFluidCodeDetails): Promise<IFluidModuleWithDetails>;
+}
+
+export declare const mockConfigProvider: (settings?: Record<string, ConfigTypes>) => IConfigProviderBase;
+
+/**
+ * Simple retry mechanism with linear back off to call
+ * a function which may eventually return an accepted value.
+ *
+ * @param callback - the function to execute
+ * @param check - the function to check if the value is acceptable
+ * @param defaultValue - the default value
+ * @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
+ */
+export declare const retryWithEventualValue: <T>(callback: () => Promise<T>, check: (value: T) => boolean, defaultValue: T, maxTries?: number, backOffMs?: number) => Promise<T>;
+
+/**
+ * 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 declare function summarizeNow(summarizer: ISummarizer, inputs?: string | IOnDemandSummarizeOptions): Promise<{
+    summaryTree: ISummaryTree;
+    summaryVersion: string;
+    summaryRefSeq: number;
+}>;
+
+export declare type SupportedExportInterfaces = Partial<IProvideRuntimeFactory & IProvideFluidDataStoreFactory & IProvideFluidDataStoreRegistry & IProvideFluidCodeDetailsComparer>;
+
+/**
+ * A container runtime factory that allows you to set runtime options
+ */
+export declare const TestContainerRuntimeFactory: {
+    new (type: string, dataStoreFactory: IFluidDataStoreFactory, runtimeOptions?: IContainerRuntimeOptions, requestHandlers?: RuntimeRequestHandler[]): {
+        type: string;
+        dataStoreFactory: IFluidDataStoreFactory;
+        runtimeOptions: IContainerRuntimeOptions;
+        requestHandlers: RuntimeRequestHandler[];
+        instantiateFirstTime(runtime: ContainerRuntime): Promise<void>;
+        instantiateFromExisting(runtime: ContainerRuntime): Promise<void>;
+        preInitialize(context: IContainerContext, existing: boolean): Promise<IRuntime & IContainerRuntime>;
+        readonly IRuntimeFactory: any;
+        instantiateRuntime(context: IContainerContext, existing: boolean): Promise<IRuntime>;
+        hasInitialized(_runtime: IContainerRuntime): Promise<void>;
+    };
+};
+
+/**
+ * A test Fluid object that will create a shared object for each key-value pair in the factoryEntries passed to load.
+ * The shared objects can be retrieved by passing the key of the entry to getSharedObject.
+ * It exposes the IFluidDataStoreContext and IFluidDataStoreRuntime.
+ */
+export declare class TestFluidObject implements ITestFluidObject {
+    readonly runtime: IFluidDataStoreRuntime;
+    readonly channel: IFluidDataStoreChannel;
+    readonly context: IFluidDataStoreContext;
+    private readonly factoryEntriesMap;
+    get ITestFluidObject(): this;
+    get IFluidLoadable(): this;
+    /**
+     * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
+    get IFluidRouter(): this;
+    get handle(): IFluidHandle<this>;
+    root: ISharedMap;
+    private readonly innerHandle;
+    private initializeP;
+    /**
+     * Creates a new TestFluidObject.
+     * @param runtime - The data store runtime.
+     * @param context - The data store context.
+     * @param factoryEntries - A list of id to IChannelFactory mapping. For each item in the list,
+     * a shared object is created which can be retrieved by calling getSharedObject() with the id;
+     */
+    constructor(runtime: IFluidDataStoreRuntime, channel: IFluidDataStoreChannel, context: IFluidDataStoreContext, factoryEntriesMap: Map<string, IChannelFactory>);
+    /**
+     * Retrieves a shared object with the given id.
+     * @param id - The id of the shared object to retrieve.
+     */
+    getSharedObject<T = any>(id: string): Promise<T>;
+    /**
+     * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
+    request(request: IRequest): Promise<IResponse>;
+    initialize(existing: boolean): Promise<void>;
+}
+
+/**
+ * Creates a factory for a TestFluidObject with the given object factory entries. It creates a data store runtime
+ * with the object factories in the entry list. All the entries with an id other than undefined are passed to the
+ * 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.
+ *
+ * ```typescript
+ * new TestFluidObjectFactory([
+ *  [ "sharedString", SharedString.getFactory() ],
+ *  [ "sharedDirectory", SharedDirectory.getFactory() ],
+ *  [ undefined, SparseMatrix.getFactory() ],
+ * ]);
+ * ```
+ *
+ * The SharedString and SharedDirectory can be retrieved via getSharedObject() on the TestFluidObject as follows:
+ *
+ * ```typescript
+ * sharedString = testFluidObject.getSharedObject<SharedString>("sharedString");
+ * sharedDir = testFluidObject.getSharedObject<SharedDirectory>("sharedDirectory");
+ * ```
+ *
+ * @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.
+ */
+export declare class TestFluidObjectFactory implements IFluidDataStoreFactory {
+    private readonly factoryEntries;
+    readonly type: string;
+    get IFluidDataStoreFactory(): this;
+    /**
+     * Creates a new TestFluidObjectFactory.
+     * @param factoryEntries - A list of id to IChannelFactory mapping. It creates a data store runtime with each
+     * IChannelFactory. Entries with string ids are passed to the Fluid object so that it can create a shared object
+     * for it.
+     */
+    constructor(factoryEntries: ChannelFactoryRegistry, type?: string);
+    instantiateDataStore(context: IFluidDataStoreContext, existing: boolean): Promise<FluidDataStoreRuntime>;
+}
+
+/**
+ * Shared base class for test object provider.  Contain code for loader and container creation and loading
+ */
+export declare class TestObjectProvider implements ITestObjectProvider {
+    readonly LoaderConstructor: typeof Loader;
+    readonly driver: ITestDriver;
+    readonly createFluidEntryPoint: (testContainerConfig?: ITestContainerConfig) => fluidEntryPoint;
+    private _loaderContainerTracker;
+    private _documentServiceFactory;
+    private _urlResolver;
+    private _logger;
+    private readonly _documentIdStrategy;
+    private _documentCreated;
+    /**
+     * Manage objects for loading and creating container, including the driver, loader, and OpProcessingController
+     * @param createFluidEntryPoint - callback to create a fluidEntryPoint, with an optional set of channel name
+     * and factory for TestFluidObject
+     */
+    constructor(LoaderConstructor: typeof Loader, driver: ITestDriver, createFluidEntryPoint: (testContainerConfig?: ITestContainerConfig) => fluidEntryPoint);
+    get logger(): EventAndErrorTrackingLogger;
+    set logger(logger: EventAndErrorTrackingLogger);
+    get documentServiceFactory(): IDocumentServiceFactory;
+    get urlResolver(): IUrlResolver;
+    get documentId(): string;
+    get defaultCodeDetails(): IFluidCodeDetails;
+    get opProcessingController(): IOpProcessingController;
+    /**
+     * Create a loader. Containers created/loaded through this loader will be added to the OpProcessingController.
+     *
+     * Only the version of the loader will vary based on compat config. The version of
+     * containerRuntime/dataRuntime used in fluidEntryPoint will be used as is from what is passed in.
+     *
+     * @param packageEntries - list of code details and fluidEntryPoint pairs.
+     */
+    createLoader(packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>, loaderProps?: Partial<ILoaderProps>): Loader;
+    /**
+     * Create a container using a default document id and code details.
+     * Container created is automatically added to the OpProcessingController to manage op flow
+     *
+     * Only the version of the loader will vary based on compat config. The version of
+     * containerRuntime/dataRuntime used in fluidEntryPoint will be used as is from what is passed in.
+     *
+     * @param packageEntries - list of code details and fluidEntryPoint pairs.
+     */
+    createContainer(entryPoint: fluidEntryPoint, loaderProps?: Partial<ILoaderProps>): Promise<IContainer>;
+    loadContainer(entryPoint: fluidEntryPoint, loaderProps?: Partial<ILoaderProps>, requestHeader?: IRequestHeader): Promise<IContainer>;
+    private resolveContainer;
+    /**
+     * Make a test loader. Containers created/loaded through this loader will be added to the OpProcessingController.
+     * The version of the loader/containerRuntime/dataRuntime may vary based on compat config of the current run
+     * @param testContainerConfig - optional configuring the test Container
+     */
+    makeTestLoader(testContainerConfig?: ITestContainerConfig): Loader;
+    /**
+     * Make a container using a default document id and code details
+     * Container loaded is automatically added to the OpProcessingController to manage op flow
+     * @param testContainerConfig - optional configuring the test Container
+     */
+    makeTestContainer(testContainerConfig?: ITestContainerConfig): Promise<IContainer>;
+    /**
+     * Load a container using a default document id and code details.
+     * IContainer loaded is automatically added to the OpProcessingController to manage op flow
+     * @param testContainerConfig - optional configuring the test Container
+     * @param requestHeader - optional headers to be supplied to the loader
+     */
+    loadTestContainer(testContainerConfig?: ITestContainerConfig, requestHeader?: IRequestHeader): Promise<IContainer>;
+    reset(): void;
+    ensureSynchronized(): Promise<void>;
+    waitContainerToCatchUp(container: IContainer): Promise<boolean>;
+    updateDocumentId(resolvedUrl: IResolvedUrl | undefined): void;
+    resetLoaderContainerTracker(syncSummarizerClients?: boolean): void;
+}
+
+/**
+ * Wraps the given promise around with promise that will complete after a specific timeout if the original promise does
+ * not resolve by then. By default, it uses the mocha test timeout and complete the promise just before that so that
+ * tests don't time out because of unpredictable awaits.
+ * The timeout can be overridden via timeoutOptions but it's recommended to use the default value.
+ * @param promise - The promise to be awaited.
+ * @param timeoutOptions - Options that can be used to override the timeout and / or define the behavior
+ * when the promise is not fulfilled. For example, instead of rejecting the promise, resolve with a
+ * specific value.
+ * @returns A new promise that will complete when the given promise resolves or the timeout expires.
+ */
+export declare function timeoutAwait<T = void>(promise: PromiseLike<T>, timeoutOptions?: TimeoutWithError | TimeoutWithValue<T>): Promise<T>;
+
+/**
+ * Creates a promise from the given executor that will complete after a specific timeout. By default, it uses the mocha
+ * test timeout and complete the promise just before that so that tests don't time out because of unpredictable awaits.
+ * The timeout can be overridden via timeoutOptions but it's recommended to use the default value.
+ * @param executor - The executor for the promise.
+ * @param timeoutOptions - Options that can be used to override the timeout and / or define the behavior when
+ * the promise is not fulfilled. For example, instead of rejecting the promise, resolve with a specific value.
+ * @returns A new promise that will complete when the given executor resolves or the timeout expires.
+ */
+export declare function timeoutPromise<T = void>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void, timeoutOptions?: TimeoutWithError | TimeoutWithValue<T>): Promise<T>;
+
+export declare interface TimeoutWithError {
+    /**
+     * Timeout duration in milliseconds, if it is great than 0 and not Infinity
+     * If it is undefined, then it will use test timeout if we are in side the test function
+     * Otherwise, there is no timeout
+     */
+    durationMs?: number;
+    reject?: true;
+    errorMsg?: string;
+}
+
+export declare interface TimeoutWithValue<T = void> {
+    /**
+     * Timeout duration in milliseconds, if it is great than 0 and not Infinity
+     * If it is undefined, then it will use test timeout if we are in side the test function
+     * Otherwise, there is no timeout
+     */
+    durationMs?: number;
+    reject: false;
+    value: T;
+}
+
+/**
+ * Utility function to wait for the specified Container to be in Connected state.
+ * If the Container is already connected, the Promise returns immediately; otherwise it resolves when the Container emits
+ * its 'connected' event.
+ * If failOnContainerClose === true, the returned Promise will be rejected if the container emits a 'closed' event
+ * before a 'connected' event.
+ * @param container - The container to wait for.
+ * @param failOnContainerClose - If true, the returned Promise will be rejected if the container emits a 'closed' event
+ * before a 'connected' event.
+ * Defaults to true.
+ * @param timeoutOptions - Options related to the behavior of the timeout.
+ * If provided, the returned Promise will reject if the container hasn't emitted relevant events in timeoutOptions.durationMs.
+ * If not provided, the Promise will wait indefinitely for the Container to emit its 'connected' (or 'closed', if
+ * failOnContainerClose === true) event.
+ *
+ * @returns A Promise that either:
+ * - Resolves when the specified container emits a 'connected' event (or immediately if the Container is already connected).
+ * - Rejects if failOnContainerClose === true and the container emits a 'closed' event before a 'connected' event.
+ * - Rejects after timeoutOptions.durationMs if timeoutOptions !== undefined and the container does not emit relevant
+ * events, within that timeframe.
+ */
+export declare function waitForContainerConnection(container: IContainer, failOnContainerClose?: boolean, timeoutOptions?: TimeoutWithError): Promise<void>;
+
+/**
+ * Wraps the given IDocumentService to override the `connectToStorage` method. The intent is to plumb the
+ * `uploadSummaryCb` to the IDocumentStorageService so that it is called whenever a summary is uploaded by
+ * the client.
+ * The document storage service that is created in `connectToStorage` is wrapped by calling `wrapDocumentStorageService`
+ * to pass in the `uploadSummaryCb`.
+ */
+export declare function wrapDocumentService(innerDocService: IDocumentService, uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext): IDocumentService;
+
+/**
+ * Wraps the given IDocumentServiceFactory to override the `createDocumentService` method. The intent is to plumb
+ * the `uploadSummaryCb` all the way to the IDocumentStorageService so that it is called whenever a summary is
+ * uploaded by the client.
+ * The document service that is created in `createDocumentService` is wrapped by calling `wrapDocumentService` to
+ * pass in the `uploadSummaryCb`.
+ */
+export declare function wrapDocumentServiceFactory(innerDocServiceFactory: IDocumentServiceFactory, uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext): IDocumentServiceFactory;
+
+/**
+ * Wraps the given IDocumentStorageService to override the `uploadSummaryWithContext` method. It calls the
+ * `uploadSummaryCb` whenever a summary is uploaded by the client. The summary context can be updated in the
+ * callback before it is uploaded to the server.
+ */
+export declare function wrapDocumentStorageService(innerDocStorageService: IDocumentStorageService, uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext): IDocumentStorageService;
+
+export { }