test(ordered-collection): Add Fuzz testing for ConsensusOrderedCollection

packages/dds/ordered-collection/package.json

@@ -130,6 +130,7 @@
 		"@arethetypeswrong/cli": "^0.17.1",
 		"@biomejs/biome": "~1.9.3",
 		"@fluid-internal/mocha-test-setup": "workspace:~",
+		"@fluid-private/stochastic-test-utils": "workspace:~",
 		"@fluid-private/test-dds-utils": "workspace:~",
 		"@fluid-tools/build-cli": "^0.58.3",
 		"@fluidframework/build-common": "^2.0.3",

packages/dds/ordered-collection/src/consensusOrderedCollection.ts

@@ -434,7 +434,7 @@ export class ConsensusOrderedCollection<T = any>
 	}
 
 	protected applyStashedOp(): void {
-		throw new Error("not implemented");
+		// empty implementation
 	}
 
 	/**

packages/dds/ordered-collection/src/test/consensusOrderedCollection.fuzz.spec.ts

@@ -0,0 +1,32 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { createDDSFuzzSuite } from "@fluid-private/test-dds-utils";
+import { FlushMode } from "@fluidframework/runtime-definitions/internal";
+
+import { baseConsensusOrderedCollectionModel, defaultOptions } from "./fuzzUtils.js";
+
+describe("ConsensusOrderedCollection fuzz testing", () => {
+	createDDSFuzzSuite(baseConsensusOrderedCollectionModel, {
+		...defaultOptions,
+		// Uncomment this line to replay a specific seed:
+		// replay: 0,
+		// This can be useful for quickly minimizing failure json while attempting to root-cause a failure.
+	});
+});
+
+describe("ConsensusOrderedCollection fuzz testing with rebasing", () => {
+	createDDSFuzzSuite(baseConsensusOrderedCollectionModel, {
+		...defaultOptions,
+		containerRuntimeOptions: {
+			flushMode: FlushMode.TurnBased,
+			enableGroupedBatching: true,
+		},
+		rebaseProbability: 0.15,
+		// Uncomment this line to replay a specific seed:
+		// replay: 0,
+		// This can be useful for quickly minimizing failure json while attempting to root-cause a failure.
+	});
+});

packages/dds/ordered-collection/src/test/dirname.cts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+// Problem:
+//   - `__dirname` is not defined in ESM
+//   - `import.meta.url` is not defined in CJS
+// Solution:
+//   - Export '__dirname' from a .cjs file in the same directory.
+//
+// Note that *.cjs files are always CommonJS, but can be imported from ESM.
+export const _dirname = __dirname;

packages/dds/ordered-collection/src/test/fuzzUtils.ts

@@ -0,0 +1,169 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { strict as assert } from "node:assert";
+import * as path from "node:path";
+
+import type {
+	AsyncGenerator as Generator,
+	Reducer,
+} from "@fluid-private/stochastic-test-utils";
+import {
+	combineReducers,
+	createWeightedAsyncGenerator as createWeightedGenerator,
+	makeRandom,
+	takeAsync as take,
+} from "@fluid-private/stochastic-test-utils";
+import type {
+	DDSFuzzModel,
+	DDSFuzzSuiteOptions,
+	DDSFuzzTestState,
+} from "@fluid-private/test-dds-utils";
+
+import { ConsensusQueueFactory } from "../consensusOrderedCollectionFactory.js";
+import type { IConsensusOrderedCollection } from "../interfaces.js";
+import { ConsensusResult } from "../interfaces.js";
+
+import { _dirname } from "./dirname.cjs";
+
+/**
+ * Config options for generating ConsensusOrderedCollection operations
+ */
+interface ConsensusOrderedCollectionValueConfig {
+	/**
+	 * Number of values to be generated for the pool
+	 */
+	valuePoolSize?: number;
+	/**
+	 * Length of value strings
+	 */
+	valueStringLength?: number;
+}
+
+const valueConfigs: Required<ConsensusOrderedCollectionValueConfig> = {
+	valuePoolSize: 3,
+	valueStringLength: 5,
+};
+
+/**
+ * Default options for ConsensusOrderedCollection fuzz testing
+ */
+export const defaultOptions: Partial<DDSFuzzSuiteOptions> = {
+	validationStrategy: { type: "fixedInterval", interval: 10 },
+	clientJoinOptions: {
+		maxNumberOfClients: 6,
+		clientAddProbability: 0.05,
+	},
+	defaultTestCount: 100,
+	saveFailures: { directory: path.join(_dirname, "../../src/test/results") },
+};
+
+type FuzzTestState = DDSFuzzTestState<ConsensusQueueFactory>;
+
+export interface AddOperation {
+	type: "add";
+	value: string;
+}
+
+export interface AcquireOperation {
+	type: "acquire";
+	resultType: ConsensusResult;
+}
+
+/**
+ * Represents ConsensusOrderedCollection operation types for fuzz testing
+ */
+export type ConsensusOrderedCollectionOperation = AddOperation | AcquireOperation;
+
+function makeOperationGenerator(): Generator<
+	ConsensusOrderedCollectionOperation,
+	FuzzTestState
+> {
+	type OpSelectionState = FuzzTestState & {
+		itemValue: string;
+	};
+
+	const valuePoolRandom = makeRandom(0);
+	const dedupe = <T>(arr: T[]): T[] => [...new Set(arr)];
+	const valuePool = dedupe(
+		Array.from({ length: valueConfigs.valuePoolSize }, () =>
+			valuePoolRandom.string(valueConfigs.valueStringLength),
+		),
+	);
+
+	async function add(state: OpSelectionState): Promise<AddOperation> {
+		return {
+			type: "add",
+			value: state.itemValue,
+		};
+	}
+
+	async function acquire(state: OpSelectionState): Promise<AcquireOperation> {
+		return {
+			type: "acquire",
+			resultType: state.random.pick([ConsensusResult.Complete, ConsensusResult.Release]),
+		};
+	}
+
+	const clientBaseOperationGenerator = createWeightedGenerator<
+		ConsensusOrderedCollectionOperation,
+		OpSelectionState
+	>([
+		[add, 1],
+		[acquire, 1],
+	]);
+
+	return async (state: FuzzTestState) =>
+		clientBaseOperationGenerator({
+			...state,
+			itemValue: state.random.pick(valuePool),
+		});
+}
+
+function makeReducer(): Reducer<ConsensusOrderedCollectionOperation, FuzzTestState> {
+	const reducer = combineReducers<ConsensusOrderedCollectionOperation, FuzzTestState>({
+		add: ({ client }, { value }) => {
+			client.channel.add(value).catch((error) => {
+				throw error;
+			});
+		},
+		acquire: ({ client }, { resultType }) => {
+			client.channel
+				.acquire(async (value) => {
+					return resultType;
+				})
+				.catch((error) => {
+					throw error;
+				});
+		},
+	});
+	return reducer;
+}
+
+function assertEqualConsensusOrderedCollections(
+	a: IConsensusOrderedCollection,
+	b: IConsensusOrderedCollection,
+): void {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
+	const aData = (a as any).data;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
+	const bData = (b as any).data;
+	assert.deepEqual(aData, bData, "Internal data properties should be equal");
+}
+
+/**
+ * Base fuzz model for ConsensusOrderedCollection
+ */
+export const baseConsensusOrderedCollectionModel: DDSFuzzModel<
+	ConsensusQueueFactory,
+	ConsensusOrderedCollectionOperation,
+	FuzzTestState
+> = {
+	workloadName: "default configuration",
+	generatorFactory: () => take(100, makeOperationGenerator()),
+	reducer: makeReducer(),
+	validateConsistency: (a, b) => assertEqualConsensusOrderedCollections(a.channel, b.channel),
+	factory: new ConsensusQueueFactory(),
+};