wip

Author: sonalideshpandemsft

packages/dds/map/src/test/directoryOracle.ts

@@ -22,42 +22,39 @@ export class SharedDirectoryOracle {
 	private readonly model = new Map<string, unknown>();
 
 	public constructor(private readonly sharedDir: ISharedDirectory) {
+		// Capture initial state BEFORE attaching event listeners
+		// to avoid double-counting any events that might fire during initialization
+		this.captureInitialSnapshot(sharedDir);
+
+		// Now attach event listeners for future changes
 		this.sharedDir.on("valueChanged", this.onValueChanged);
 		this.sharedDir.on("clear", this.onClear);
 		this.sharedDir.on("subDirectoryCreated", this.onSubDirCreated);
 		this.sharedDir.on("subDirectoryDeleted", this.onSubDirDeleted);
 		this.sharedDir.on("containedValueChanged", this.onContainedValueChanged);
-
-		this.captureInitialSnapshot(sharedDir);
 	}
 
 	private captureInitialSnapshot(dir: IDirectory): void {
+		const { absolutePath } = dir;
+
 		// Capture keys
 		for (const [key, value] of dir.entries()) {
-			const pathKey = dir.absolutePath === "/" ? `/${key}` : `${dir.absolutePath}/${key}`;
-
+			const pathKey = absolutePath === "/" ? `/${key}` : `${absolutePath}/${key}`;
 			this.model.set(pathKey, value);
 		}
 
+		// Recurse into subdirectories to capture their keys
 		for (const [, subDir] of dir.subdirectories()) {
-			// Just recurse to capture keys inside the subdir
 			this.captureInitialSnapshot(subDir);
 		}
 	}
 
 	private readonly onValueChanged = (change: IDirectoryValueChanged) => {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-		const { key, previousValue } = change;
+		const { key } = change;
 		const path = change.path ?? "";
 
 		const pathKey = path === "/" ? `/${key}` : `${path}/${key}`;
 
-		assert.strictEqual(
-			previousValue,
-			this.model.get(pathKey),
-			`Mismatch on previous value for key="${key}"`,
-		);
-
 		const fuzzDir = this.sharedDir.getWorkingDirectory(path);
 		if (!fuzzDir) return;
 
@@ -69,28 +66,36 @@ export class SharedDirectoryOracle {
 	};
 
 	private readonly onClear = (local: boolean) => {
-		this.model.clear();
+		// Clear only root-level keys, not subdirectories or their contents
+		for (const key of [...this.model.keys()]) {
+			const parts = key.split("/").filter((p) => p.length > 0);
+			if (parts.length === 1) {
+				// Root-level key like "/key1"
+				this.model.delete(key);
+			}
+		}
 	};
 
 	private readonly onSubDirCreated = (
-		subdirName: string,
+		path: string,
 		local: boolean,
 		target: ISharedDirectory,
 	) => {
-		const { absolutePath } = target;
-		if (!this.model.has(`${absolutePath}${subdirName}`)) {
-			this.model.set(`${absolutePath}${subdirName}`, undefined);
+		// path is relative from root, e.g., "dir1" or "dir1/dir2"
+		const subdirPath = path.startsWith("/") ? path : `/${path}`;
+		if (!this.model.has(subdirPath)) {
+			this.model.set(subdirPath, undefined);
 		}
 	};
 
 	private readonly onSubDirDeleted = (path: string) => {
 		const absPath = path.startsWith("/") ? path : `/${path}`;
+		const prefix = `${absPath}/`;
+
 		for (const key of [...this.model.keys()]) {
-			if (key.startsWith(absPath)) {
-				const deleted = this.model.delete(key);
-				if (!deleted) {
-					assert("not deleted");
-				}
+			// Delete all keys under the deleted subdirectory
+			if (key.startsWith(prefix)) {
+				this.model.delete(key);
 			}
 		}
 	};
@@ -100,18 +105,11 @@ export class SharedDirectoryOracle {
 		local: boolean,
 		target: IDirectory,
 	) => {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-		const { key, previousValue } = change;
+		const { key } = change;
 		const { absolutePath } = target;
 
 		const pathKey = absolutePath === "/" ? `/${key}` : `${absolutePath}/${key}`;
 
-		assert.strictEqual(
-			previousValue,
-			this.model.get(pathKey),
-			`Mismatch on previous value for key="${key}"`,
-		);
-
 		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 		const newValue = target.get(key);
 
@@ -123,29 +121,33 @@ export class SharedDirectoryOracle {
 	};
 
 	public validate(): void {
-		for (const [pathKey, value] of this.model.entries()) {
-			const parts = pathKey.split("/").filter((p) => p.length > 0);
-			assert(parts.length > 0, "Invalid path, cannot extract key");
+		this.validateDirectory(this.sharedDir);
+	}
 
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			const leafKey = parts.pop()!; // The actual key
-			let dir: IDirectory | undefined = this.sharedDir;
+	private validateDirectory(dir: IDirectory): void {
+		const { absolutePath } = dir;
 
-			for (const part of parts) {
-				dir = dir.getSubDirectory(part);
-				if (!dir) break;
+		// Check all keys in this directory
+		for (const [key, value] of dir.entries()) {
+			const pathKey = absolutePath === "/" ? `/${key}` : `${absolutePath}/${key}`;
+
+			// Only validate keys that the oracle is tracking
+			// (keys loaded from snapshots may not fire events)
+			if (this.model.has(pathKey)) {
+				// Verify oracle has the correct value
+				assert.deepStrictEqual(
+					this.model.get(pathKey),
+					value,
+					`Value mismatch for key "${pathKey}": oracle=${this.model.get(pathKey)}, actual=${value}`,
+				);
 			}
+		}
 
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-			const actual = dir?.get(leafKey);
-			assert.deepStrictEqual(
-				actual,
-				value,
-				`SharedDirectoryOracle mismatch at path="${pathKey}" with actual value = ${actual} and oracle value = ${value} with model entries = ${JSON.stringify(this.model.entries())}}`,
-			);
+		// Recursively validate subdirectories
+		for (const [, subdir] of dir.subdirectories()) {
+			this.validateDirectory(subdir);
 		}
 	}
-
 	public dispose(): void {
 		this.sharedDir.off("valueChanged", this.onValueChanged);
 		this.sharedDir.off("clear", this.onClear);