Unit test works and covers the changes to SharedObjectFromKernel.

Author: TommyBrosman

packages/dds/shared-object-base/src/test/createSharedObjectKind.spec.ts

@@ -11,17 +11,33 @@ import type {
 	IChannelAttributes,
 	IChannelFactory,
 	IChannelServices,
+	IChannelStorageService,
 	IFluidDataStoreRuntime,
 	IFluidDataStoreRuntimeInternalConfig,
 } from "@fluidframework/datastore-definitions/internal";
-import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
+import type {
+	IExperimentalIncrementalSummaryContext,
+	IRuntimeMessageCollection,
+	ISummaryTreeWithStats,
+	ITelemetryContext,
+	MinimumVersionForCollab,
+} from "@fluidframework/runtime-definitions/internal";
 import { MockFluidDataStoreRuntime } from "@fluidframework/test-runtime-utils/internal";
 
+import type { IFluidSerializer } from "../serializer.js";
 import { createSharedObjectKind } from "../sharedObject.js";
+import {
+	makeSharedObjectKind,
+	type FactoryOut,
+	type KernelArgs,
+	type SharedKernel,
+	type SharedKernelFactory,
+	type SharedObjectOptions,
+} from "../sharedObjectKernel.js";
 
 interface IFoo {
 	foo: string;
-	minVersionForCollab: MinimumVersionForCollab;
+	minVersionForCollab: MinimumVersionForCollab | undefined;
 }
 class SharedFooFactory implements IChannelFactory<IFoo> {
 	public static readonly Type: string = "SharedFoo";
@@ -88,11 +104,120 @@ describe("createSharedObjectKind's return type", () => {
 	});
 });
 
+/**
+ * The options used to construct a `FooKernelFactory`.
+ */
+interface FooOptionsInternal {
+	readonly minVersionForCollab: MinimumVersionForCollab;
+}
+
+/**
+ * A minimal implementation of a `KernelView` based on `SharedTreeKernelView` in the \@fluidframework/tree package.
+ */
+interface FooKernelView extends IFoo {
+	readonly kernel: FooKernel;
+	readonly minVersionForCollab: MinimumVersionForCollab | undefined;
+	readonly foo: string;
+}
+
+/**
+ * A minimal implementation of a `SharedKernel` that builds a view containing the `minVersionForCollab` it was
+ * constructed with. Does not provide any method implementations beyond the constructor.
+ */
+class FooKernel implements SharedKernel {
+	public readonly view: FooKernelView;
+
+	constructor(minVersionForCollab: MinimumVersionForCollab | undefined) {
+		this.view = {
+			kernel: this,
+			minVersionForCollab,
+			foo: "foo",
+		};
+	}
+
+	summarizeCore(
+		serializer: IFluidSerializer,
+		telemetryContext: ITelemetryContext | undefined,
+		incrementalSummaryContext: IExperimentalIncrementalSummaryContext | undefined,
+		fullTree?: boolean,
+	): ISummaryTreeWithStats {
+		throw new Error("Method not implemented.");
+	}
+	onDisconnect(): void {
+		throw new Error("Method not implemented.");
+	}
+	reSubmitCore(content: unknown, localOpMetadata: unknown): void {
+		throw new Error("Method not implemented.");
+	}
+	applyStashedOp(content: unknown): void {
+		throw new Error("Method not implemented.");
+	}
+	processMessagesCore(messagesCollection: IRuntimeMessageCollection): void {
+		throw new Error("Method not implemented.");
+	}
+	rollback?(content: unknown, localOpMetadata: unknown): void {
+		throw new Error("Method not implemented.");
+	}
+	didAttach?(): void {
+		throw new Error("Method not implemented.");
+	}
+}
+
 describe("createSharedObjectKind with minVersionForCollab", () => {
-	it("SharedObject can read minVersionForCollab from the runtime", () => {
-		const factory = SharedFoo.getFactory();
-		const runtime = new MockFluidDataStoreRuntime({ minVersionForCollab: "1.2.3" });
-		const sharedObject = factory.create(runtime, "test-id");
-		assert.strictEqual(sharedObject.minVersionForCollab, "1.2.3");
+	/**
+	 * A simple KernelFactory that creates a `FooKernel` with the `minVersionForCollab` from its constructor arguments.
+	 * @param options - The options for the factory.
+	 * @returns A `SharedKernelFactory` that creates `FooKernelView` instances.
+	 */
+	function fooKernelFactory(options: FooOptionsInternal): SharedKernelFactory<FooKernelView> {
+		function fooFromKernelArgs(args: KernelArgs): FooKernel {
+			return new FooKernel(args.minVersionForCollab);
+		}
+
+		return {
+			create(args: KernelArgs): FactoryOut<FooKernelView> {
+				const kernel = fooFromKernelArgs(args);
+				return { kernel, view: kernel.view };
+			},
+			async loadCore(
+				args: KernelArgs,
+				storage: IChannelStorageService,
+			): Promise<FactoryOut<FooKernelView>> {
+				const kernel = fooFromKernelArgs(args);
+				// There is no differentiation between load and create for the purposes of this test.
+				return { kernel, view: kernel.view };
+			},
+		};
+	}
+
+	it("SharedObject can be constructed with a minVersionForCollab from the runtime", () => {
+		const minVersionForCollab = "1.2.3";
+		const type = "Foo";
+
+		const attributes: IChannelAttributes = {
+			type,
+			snapshotFormatVersion: "0.1",
+			packageVersion: "2.0.0",
+		};
+
+		const options: FooOptionsInternal = {
+			minVersionForCollab,
+		};
+
+		const sharedObjectOptions: SharedObjectOptions<IFoo> = {
+			type: "",
+			attributes,
+			telemetryContextPrefix: "foo_",
+			factory: fooKernelFactory(options),
+		};
+
+		const LocalSharedFoo = makeSharedObjectKind(sharedObjectOptions);
+		const runtime = new MockFluidDataStoreRuntime({
+			registry: [LocalSharedFoo.getFactory()],
+			minVersionForCollab,
+		});
+		const foo = LocalSharedFoo.create(runtime, "test-id");
+
+		assert.strictEqual(foo.minVersionForCollab, "1.2.3");
 	});
 });

packages/runtime/test-runtime-utils/api-report/test-runtime-utils.legacy.beta.api.md

@@ -470,6 +470,8 @@ export class MockFluidDataStoreRuntime extends EventEmitter implements IFluidDat
     // (undocumented)
     makeVisibleAndAttachGraph(): void;
     // (undocumented)
+    readonly minVersionForCollab: MinimumVersionForCollab | undefined;
+    // (undocumented)
     notifyReadOnlyState(readonly: boolean): void;
     // (undocumented)
     get objectsRoutingContext(): IFluidHandleContext;

packages/runtime/test-runtime-utils/package.json

@@ -156,6 +156,9 @@
 		"broken": {
 			"Class_MockFluidDataStoreContext": {
 				"forwardCompat": false
+			},
+			"Class_MockFluidDataStoreRuntime": {
+				"forwardCompat": false
 			}
 		},
 		"entrypoint": "legacy"

packages/runtime/test-runtime-utils/src/mocks.ts

@@ -880,13 +880,20 @@ export class MockFluidDataStoreRuntime
 		if (registry) {
 			this.registry = new Map(registry.map((factory) => [factory.type, factory]));
 		}
+
+		this.minVersionForCollab = overrides?.minVersionForCollab;
 	}
 
 	private readonly: boolean = false;
 	public readonly isReadOnly = () => this.readonly;
 
 	public readonly entryPoint: IFluidHandleInternal<FluidObject>;
 
+	/**
+	 * @see IFluidDataStoreRuntimeInternalConfig.minVersionForCollab
+	 */
+	public readonly minVersionForCollab: MinimumVersionForCollab | undefined;
+
 	public get IFluidHandleContext(): IFluidHandleContext {
 		return this;
 	}

packages/runtime/test-runtime-utils/src/test/types/validateTestRuntimeUtilsPrevious.generated.ts

@@ -185,6 +185,7 @@ declare type current_as_old_for_Class_MockFluidDataStoreContext = requireAssigna
  * typeValidation.broken:
  * "Class_MockFluidDataStoreRuntime": {"forwardCompat": false}
  */
+// @ts-expect-error compatibility expected to be broken
 declare type old_as_current_for_Class_MockFluidDataStoreRuntime = requireAssignableTo<TypeOnly<old.MockFluidDataStoreRuntime>, TypeOnly<current.MockFluidDataStoreRuntime>>
 
 /*