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

package/src/testFluidObject.ts

@@ -5,19 +5,23 @@
 
 import { defaultFluidObjectRequestHandler } from "@fluidframework/aqueduct";
 import {
-    IRequest,
-    IResponse,
-    IFluidHandle,
-    IFluidRouter,
-    FluidObject,
-    IProvideFluidRouter,
+	IRequest,
+	IResponse,
+	IFluidHandle,
+	IFluidRouter,
+	FluidObject,
+	IProvideFluidRouter,
 } from "@fluidframework/core-interfaces";
-import { FluidObjectHandle, FluidDataStoreRuntime, mixinRequestHandler } from "@fluidframework/datastore";
+import {
+	FluidObjectHandle,
+	FluidDataStoreRuntime,
+	mixinRequestHandler,
+} from "@fluidframework/datastore";
 import { SharedMap, ISharedMap } from "@fluidframework/map";
 import {
-    IFluidDataStoreContext,
-    IFluidDataStoreFactory,
-    IFluidDataStoreChannel,
+	IFluidDataStoreContext,
+	IFluidDataStoreFactory,
+	IFluidDataStoreChannel,
 } from "@fluidframework/runtime-definitions";
 import { IFluidDataStoreRuntime, IChannelFactory } from "@fluidframework/datastore-definitions";
 import { assert } from "@fluidframework/common-utils";
@@ -29,89 +33,91 @@ import { ITestFluidObject } from "./interfaces";
  * It exposes the IFluidDataStoreContext and IFluidDataStoreRuntime.
  */
 export class TestFluidObject implements ITestFluidObject, IFluidRouter {
-    public static async load(
-        runtime: IFluidDataStoreRuntime,
-        channel: IFluidDataStoreChannel,
-        context: IFluidDataStoreContext,
-        factoryEntries: Map<string, IChannelFactory>,
-        existing: boolean,
-    ) {
-        const fluidObject = new TestFluidObject(runtime, channel, context, factoryEntries);
-        await fluidObject.initialize(existing);
-
-        return fluidObject;
-    }
-
-    public get ITestFluidObject() {
-        return this;
-    }
-
-    public get IFluidLoadable() {
-        return this;
-    }
-
-    public get IFluidRouter() {
-        return this;
-    }
-
-    public get handle(): IFluidHandle<this> { return this.innerHandle; }
-
-    public root!: ISharedMap;
-    private readonly innerHandle: IFluidHandle<this>;
-
-    /**
-     * 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(
-        public readonly runtime: IFluidDataStoreRuntime,
-        public readonly channel: IFluidDataStoreChannel,
-        public readonly context: IFluidDataStoreContext,
-        private readonly factoryEntriesMap: Map<string, IChannelFactory>,
-    ) {
-        this.innerHandle = new FluidObjectHandle(this, "", runtime.objectsRoutingContext);
-    }
-
-    /**
-     * Retrieves a shared object with the given id.
-     * @param id - The id of the shared object to retrieve.
-     */
-    public async getSharedObject<T = any>(id: string): Promise<T> {
-        if (this.factoryEntriesMap === undefined) {
-            throw new Error("Shared objects were not provided during creation.");
-        }
-
-        for (const key of this.factoryEntriesMap.keys()) {
-            if (key === id) {
-                const handle = this.root.get<IFluidHandle>(id);
-                return handle?.get() as unknown as T;
-            }
-        }
-
-        throw new Error(`Shared object with id ${id} not found.`);
-    }
-
-    public async request(request: IRequest): Promise<IResponse> {
-        return defaultFluidObjectRequestHandler(this, request);
-    }
-
-    private async initialize(existing: boolean) {
-        if (!existing) {
-            this.root = SharedMap.create(this.runtime, "root");
-
-            this.factoryEntriesMap.forEach((sharedObjectFactory: IChannelFactory, key: string) => {
-                const sharedObject = this.runtime.createChannel(key, sharedObjectFactory.type);
-                this.root.set(key, sharedObject.handle);
-            });
-
-            this.root.bindToContext();
-        }
-
-        this.root = await this.runtime.getChannel("root") as ISharedMap;
-    }
+	public static async load(
+		runtime: IFluidDataStoreRuntime,
+		channel: IFluidDataStoreChannel,
+		context: IFluidDataStoreContext,
+		factoryEntries: Map<string, IChannelFactory>,
+		existing: boolean,
+	) {
+		const fluidObject = new TestFluidObject(runtime, channel, context, factoryEntries);
+		await fluidObject.initialize(existing);
+
+		return fluidObject;
+	}
+
+	public get ITestFluidObject() {
+		return this;
+	}
+
+	public get IFluidLoadable() {
+		return this;
+	}
+
+	public get IFluidRouter() {
+		return this;
+	}
+
+	public get handle(): IFluidHandle<this> {
+		return this.innerHandle;
+	}
+
+	public root!: ISharedMap;
+	private readonly innerHandle: IFluidHandle<this>;
+
+	/**
+	 * 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(
+		public readonly runtime: IFluidDataStoreRuntime,
+		public readonly channel: IFluidDataStoreChannel,
+		public readonly context: IFluidDataStoreContext,
+		private readonly factoryEntriesMap: Map<string, IChannelFactory>,
+	) {
+		this.innerHandle = new FluidObjectHandle(this, "", runtime.objectsRoutingContext);
+	}
+
+	/**
+	 * Retrieves a shared object with the given id.
+	 * @param id - The id of the shared object to retrieve.
+	 */
+	public async getSharedObject<T = any>(id: string): Promise<T> {
+		if (this.factoryEntriesMap === undefined) {
+			throw new Error("Shared objects were not provided during creation.");
+		}
+
+		for (const key of this.factoryEntriesMap.keys()) {
+			if (key === id) {
+				const handle = this.root.get<IFluidHandle>(id);
+				return handle?.get() as unknown as T;
+			}
+		}
+
+		throw new Error(`Shared object with id ${id} not found.`);
+	}
+
+	public async request(request: IRequest): Promise<IResponse> {
+		return defaultFluidObjectRequestHandler(this, request);
+	}
+
+	private async initialize(existing: boolean) {
+		if (!existing) {
+			this.root = SharedMap.create(this.runtime, "root");
+
+			this.factoryEntriesMap.forEach((sharedObjectFactory: IChannelFactory, key: string) => {
+				const sharedObject = this.runtime.createChannel(key, sharedObjectFactory.type);
+				this.root.set(key, sharedObject.handle);
+			});
+
+			this.root.bindToContext();
+		}
+
+		this.root = (await this.runtime.getChannel("root")) as ISharedMap;
+	}
 }
 
 export type ChannelFactoryRegistry = Iterable<[string | undefined, IChannelFactory]>;
@@ -141,63 +147,73 @@ export type ChannelFactoryRegistry = Iterable<[string | undefined, IChannelFacto
  * ```
  */
 export class TestFluidObjectFactory implements IFluidDataStoreFactory {
-    public get IFluidDataStoreFactory() { return 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(private readonly factoryEntries: ChannelFactoryRegistry,
-        public readonly type = "TestFluidObjectFactory") { }
-
-    public async instantiateDataStore(
-        context: IFluidDataStoreContext,
-        existing: boolean,
-    ): Promise<FluidDataStoreRuntime> {
-        const dataTypes = new Map<string, IChannelFactory>();
-
-        // Add SharedMap's factory which will be used to create the root map.
-        const sharedMapFactory = SharedMap.getFactory();
-        dataTypes.set(sharedMapFactory.type, sharedMapFactory);
-
-        // Add the object factories to the list to be sent to data store runtime.
-        for (const entry of this.factoryEntries) {
-            const factory = entry[1];
-            dataTypes.set(factory.type, factory);
-        }
-
-        // Create a map from the factory entries with entries that don't have the id as undefined. This will be
-        // passed to the Fluid object.
-        const factoryEntriesMapForObject = new Map<string, IChannelFactory>();
-        for (const entry of this.factoryEntries) {
-            const id = entry[0];
-            if (id !== undefined) {
-                factoryEntriesMapForObject.set(id, entry[1]);
-            }
-        }
-
-        const runtimeClass = mixinRequestHandler(
-            async (request: IRequest, rt: FluidDataStoreRuntime) => {
-                const maybeRouter: FluidObject<IProvideFluidRouter> | undefined
-                    = await rt.entryPoint?.get();
-                assert(maybeRouter?.IFluidRouter !== undefined, "entryPoint should have been initialized by now");
-                return maybeRouter.IFluidRouter.request(request);
-            });
-
-        return new runtimeClass(
-            context,
-            dataTypes,
-            existing,
-            async (dataStoreRuntime: IFluidDataStoreRuntime) => TestFluidObject.load(
-                dataStoreRuntime,
-                // This works because 'runtime' is an instance of runtimeClass (which is a FluidDataStoreRuntime and
-                // thus implements IFluidDataStoreChannel) which passes itself as the parameter to this function.
-                dataStoreRuntime as FluidDataStoreRuntime,
-                context,
-                factoryEntriesMapForObject,
-                existing,
-            ));
-    }
+	public get IFluidDataStoreFactory() {
+		return 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(
+		private readonly factoryEntries: ChannelFactoryRegistry,
+		public readonly type = "TestFluidObjectFactory",
+	) {}
+
+	public async instantiateDataStore(
+		context: IFluidDataStoreContext,
+		existing: boolean,
+	): Promise<FluidDataStoreRuntime> {
+		const dataTypes = new Map<string, IChannelFactory>();
+
+		// Add SharedMap's factory which will be used to create the root map.
+		const sharedMapFactory = SharedMap.getFactory();
+		dataTypes.set(sharedMapFactory.type, sharedMapFactory);
+
+		// Add the object factories to the list to be sent to data store runtime.
+		for (const entry of this.factoryEntries) {
+			const factory = entry[1];
+			dataTypes.set(factory.type, factory);
+		}
+
+		// Create a map from the factory entries with entries that don't have the id as undefined. This will be
+		// passed to the Fluid object.
+		const factoryEntriesMapForObject = new Map<string, IChannelFactory>();
+		for (const entry of this.factoryEntries) {
+			const id = entry[0];
+			if (id !== undefined) {
+				factoryEntriesMapForObject.set(id, entry[1]);
+			}
+		}
+
+		const runtimeClass = mixinRequestHandler(
+			async (request: IRequest, rt: FluidDataStoreRuntime) => {
+				const maybeRouter: FluidObject<IProvideFluidRouter> | undefined =
+					await rt.entryPoint?.get();
+				assert(
+					maybeRouter?.IFluidRouter !== undefined,
+					"entryPoint should have been initialized by now",
+				);
+				return maybeRouter.IFluidRouter.request(request);
+			},
+		);
+
+		return new runtimeClass(
+			context,
+			dataTypes,
+			existing,
+			async (dataStoreRuntime: IFluidDataStoreRuntime) =>
+				TestFluidObject.load(
+					dataStoreRuntime,
+					// This works because 'runtime' is an instance of runtimeClass (which is a FluidDataStoreRuntime and
+					// thus implements IFluidDataStoreChannel) which passes itself as the parameter to this function.
+					dataStoreRuntime as FluidDataStoreRuntime,
+					context,
+					factoryEntriesMapForObject,
+					existing,
+				),
+		);
+	}
 }