@fluidframework/test-utils 2.31.1 → 2.33.0-333010

package/src/testFluidObject.ts

@@ -3,7 +3,12 @@
  * Licensed under the MIT License.
  */
 
-import { IFluidHandle, IRequest, IResponse } from "@fluidframework/core-interfaces";
+import {
+	IFluidHandle,
+	IRequest,
+	IResponse,
+	type IFluidLoadable,
+} from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 import {
 	FluidDataStoreRuntime,
@@ -21,13 +26,18 @@ import {
 	IFluidDataStoreFactory,
 } from "@fluidframework/runtime-definitions/internal";
 import { create404Response } from "@fluidframework/runtime-utils/internal";
+import type { ISharedObject } from "@fluidframework/shared-object-base/internal";
 
 import { ITestFluidObject } from "./interfaces.js";
 
 /**
- * A test Fluid object that will create a shared object for each key-value pair in the factoryEntries passed to load.
+ * A test Fluid object that will create a shared object for each key-value pair in the initialSharedObjectsFactories passed to load.
  * The shared objects can be retrieved by passing the key of the entry to getSharedObject.
  * It exposes the IFluidDataStoreContext and IFluidDataStoreRuntime.
+ * @privateRemarks
+ * TODO:
+ * Usage of this outside this repo (via ITestFluidObject) should probably be phased out.
+ * Once thats done, ITestFluidObject can be made internal and this class can be replaced with the simplified TestFluidObjectInternal.
  * @internal
  */
 export class TestFluidObject implements ITestFluidObject {
@@ -39,28 +49,28 @@ export class TestFluidObject implements ITestFluidObject {
 		return this;
 	}
 
-	public get handle(): IFluidHandle<this> {
-		return this.innerHandle;
-	}
+	public readonly handle: IFluidHandle<this>;
 
 	public root!: ISharedMap;
-	private readonly innerHandle: IFluidHandle<this>;
 	private initializationPromise: Promise<void> | undefined;
 
 	/**
 	 * 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,
+	 * @param initialSharedObjectsFactories - 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>,
+		private readonly initialSharedObjectsFactories: ReadonlyMap<
+			string,
+			IChannelFactory<ISharedObject>
+		>,
 	) {
-		this.innerHandle = new FluidObjectHandle(this, "", runtime.objectsRoutingContext);
+		this.handle = new FluidObjectHandle(this, "", runtime.objectsRoutingContext);
 	}
 
 	/**
@@ -68,15 +78,15 @@ export class TestFluidObject implements ITestFluidObject {
 	 * @param id - The id of the shared object to retrieve.
 	 */
 	public async getSharedObject<T = any>(id: string): Promise<T> {
-		if (this.factoryEntriesMap === undefined) {
+		if (this.initialSharedObjectsFactories === undefined) {
 			throw new Error("Shared objects were not provided during creation.");
 		}
 
-		if (this.factoryEntriesMap.has(id)) {
+		if (this.initialSharedObjectsFactories.has(id)) {
 			const handle = this.root.get<IFluidHandle<T>>(id);
 			if (handle === undefined) {
 				throw new Error(
-					`Shared object with id '${id}' is in factoryEntriesMap but not found under root.`,
+					`Shared object with id '${id}' is in initialSharedObjectsFactories but not found under root.`,
 				);
 			}
 			return handle.get();
@@ -96,10 +106,12 @@ export class TestFluidObject implements ITestFluidObject {
 			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.initialSharedObjectsFactories.forEach(
+					(sharedObjectFactory: IChannelFactory, key: string) => {
+						const sharedObject = this.runtime.createChannel(key, sharedObjectFactory.type);
+						this.root.set(key, sharedObject.handle);
+					},
+				);
 
 				this.root.bindToContext();
 			}
@@ -118,6 +130,20 @@ export class TestFluidObject implements ITestFluidObject {
  */
 export type ChannelFactoryRegistry = Iterable<[string | undefined, IChannelFactory]>;
 
+/**
+ * Kind of test data object which {@link TestFluidObjectFactory} can create.
+ * @internal
+ */
+export type TestDataObjectKind = new (
+	runtime: IFluidDataStoreRuntime,
+	channel: IFluidDataStoreChannel,
+	context: IFluidDataStoreContext,
+	initialSharedObjectsFactories: ReadonlyMap<string, IChannelFactory<ISharedObject>>,
+) => IFluidLoadable & {
+	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
@@ -156,13 +182,14 @@ export class TestFluidObjectFactory implements IFluidDataStoreFactory {
 
 	/**
 	 * Creates a new TestFluidObjectFactory.
-	 * @param factoryEntries - A list of id to IChannelFactory mapping. It creates a data store runtime with each
+	 * @param initialSharedObjectsFactories - 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,
+		private readonly initialSharedObjectsFactories: ChannelFactoryRegistry,
 		public readonly type = "TestFluidObjectFactory",
+		private readonly dataObjectKind: TestDataObjectKind = TestFluidObject,
 	) {}
 
 	public async instantiateDataStore(
@@ -176,16 +203,17 @@ export class TestFluidObjectFactory implements IFluidDataStoreFactory {
 		dataTypes.set(sharedMapFactory.type, sharedMapFactory);
 
 		// Add the object factories to the list to be sent to data store runtime.
-		for (const [, factory] of this.factoryEntries) {
+		for (const [, factory] of this.initialSharedObjectsFactories) {
 			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 [id, factory] of this.factoryEntries) {
+		const factoryEntriesMapForObject = new Map<string, IChannelFactory<ISharedObject>>();
+		for (const [id, factory] of this.initialSharedObjectsFactories) {
 			if (id !== undefined) {
-				factoryEntriesMapForObject.set(id, factory);
+				// Here we assume the factory produces an ISharedObject.
+				factoryEntriesMapForObject.set(id, factory as IChannelFactory<ISharedObject>);
 			}
 		}
 
@@ -194,19 +222,24 @@ export class TestFluidObjectFactory implements IFluidDataStoreFactory {
 				// The provideEntryPoint callback below always returns TestFluidObject.
 				const dataObject = await rt.entryPoint.get();
 				assert(
-					dataObject instanceof TestFluidObject,
+					dataObject instanceof this.dataObjectKind,
 					"entryPoint should have been initialized by now",
 				);
 				return dataObject.request(request);
 			},
 		);
 
-		const runtime = new runtimeClass(context, dataTypes, existing, async () => {
-			await instance.initialize(true);
-			return instance;
-		});
+		const runtime: FluidDataStoreRuntime = new runtimeClass(
+			context,
+			dataTypes,
+			existing,
+			async () => {
+				await instance.initialize(true);
+				return instance;
+			},
+		);
 
-		const instance: TestFluidObject = new TestFluidObject(
+		const instance = new this.dataObjectKind(
 			runtime, // runtime
 			runtime, // channel
 			context,

package/src/testFluidObjectInternal.ts

@@ -0,0 +1,110 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	IFluidHandle,
+	IRequest,
+	IResponse,
+	type IFluidLoadable,
+} from "@fluidframework/core-interfaces";
+import { fail } from "@fluidframework/core-utils/internal";
+import { FluidObjectHandle } from "@fluidframework/datastore/internal";
+import {
+	IChannelFactory,
+	IFluidDataStoreRuntime,
+	type IChannel,
+} from "@fluidframework/datastore-definitions/internal";
+import {
+	IFluidDataStoreChannel,
+	IFluidDataStoreContext,
+} from "@fluidframework/runtime-definitions/internal";
+import { create404Response } from "@fluidframework/runtime-utils/internal";
+import type {
+	ISharedObject,
+	SharedObjectKind,
+} from "@fluidframework/shared-object-base/internal";
+
+/**
+ * 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 {@link TestFluidObjectInternal.getInitialSharedObject}.
+ * It exposes the IFluidDataStoreContext and IFluidDataStoreRuntime.
+ * @remarks
+ * This is a simplified (does not use SharedMap) alternative to {@link TestFluidObject} which does not implement the external facing {@link ITestFluidObject} interface.
+ * @internal
+ */
+export class TestFluidObjectInternal implements IFluidLoadable {
+	public get IFluidLoadable() {
+		return this;
+	}
+
+	public readonly handle: IFluidHandle<this>;
+	private initializationPromise: Promise<void> | undefined;
+
+	/**
+	 * Creates a new TestFluidObjectInternal.
+	 * @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 {@link TestFluidObjectInternal.getInitialSharedObject} with the id;
+	 * @param initialSharedObjectsFactories - A collection of ids (which can be passed to {@link TestFluidObjectInternal.getInitialSharedObject})
+	 * and the corresponding factories to use to create the shared objects during initialization.
+	 */
+	constructor(
+		public readonly runtime: IFluidDataStoreRuntime,
+		public readonly channel: IFluidDataStoreChannel,
+		public readonly context: IFluidDataStoreContext,
+		private readonly initialSharedObjectsFactories: ReadonlyMap<
+			string,
+			IChannelFactory<ISharedObject>
+		>,
+	) {
+		this.handle = new FluidObjectHandle(this, "", runtime.objectsRoutingContext);
+	}
+
+	/**
+	 * Retrieves the shared object with the given id:
+	 * this id must have been a key included in the initialSharedObjectsFactories map passed to the constructor.
+	 * @param id - The id of the shared object to retrieve.
+	 */
+	public async getInitialSharedObject(id: string): Promise<IChannel> {
+		return (await this.runtime.getChannel(id)) ?? fail("Shared object not found");
+	}
+
+	/**
+	 * Retrieves a shared object with the given id.
+	 * @param kind - The kind of object to retrieve.
+	 * @param id - The id of the shared object to retrieve.
+	 */
+	public async getInitialSharedObjectTyped<T>(
+		kind: SharedObjectKind<T>,
+		id: string,
+	): Promise<IChannel & T> {
+		const result = (await this.runtime.getChannel(id)) ?? fail("Shared object not found");
+		if (kind.is(result)) {
+			return result;
+		}
+		return fail("Wrong kind of shared object");
+	}
+
+	public async request(request: IRequest): Promise<IResponse> {
+		return request.url === "" || request.url === "/" || request.url.startsWith("/?")
+			? { mimeType: "fluid/object", status: 200, value: this }
+			: create404Response(request);
+	}
+
+	public async initialize(existing: boolean) {
+		const doInitialization = async () => {
+			if (!existing) {
+				for (const [key, sharedObjectFactory] of this.initialSharedObjectsFactories) {
+					const channel = this.runtime.createChannel(key, sharedObjectFactory.type);
+					(channel as ISharedObject).bindToContext();
+				}
+			}
+		};
+
+		this.initializationPromise ??= doInitialization();
+		return this.initializationPromise;
+	}
+}