Fix testing setup

frontend/sync-client/src/file-operations/file-operations.test.ts

@@ -7,94 +7,108 @@ import { FileOperations } from "./file-operations";
 import { Logger } from "../tracing/logger";
 import { assertSetContainsExactly } from "../utils/assert-set-contains-exactly";
 import type { FileSystemOperations } from "./filesystem-operations";
+import init, { base64ToBytes } from "sync_lib";
+import fs from "fs";
+
+class MockDatabase implements Partial<Database> {
+	public getLatestDocumentByRelativePath(
+		_find: RelativePath
+	): DocumentRecord | undefined {
+		// no-op
+		return undefined;
+	}
+
+	public move(
+		_oldRelativePath: RelativePath,
+		_newRelativePath: RelativePath
+	): void {
+		// no-op
+	}
+}
+
+class FakeFileSystemOperations implements FileSystemOperations {
+	public readonly names = new Set<string>();
+
+	public async listAllFiles(): Promise<RelativePath[]> {
+		throw new Error("Method not implemented.");
+	}
+	public async read(_path: RelativePath): Promise<Uint8Array> {
+		throw new Error("Method not implemented.");
+	}
+	public async write(
+		path: RelativePath,
+		_content: Uint8Array
+	): Promise<void> {
+		this.names.add(path);
+	}
+	public async atomicUpdateText(
+		_path: RelativePath,
+		_updater: (currentContent: string) => string
+	): Promise<string> {
+		throw new Error("Method not implemented.");
+	}
+	public async getFileSize(_path: RelativePath): Promise<number> {
+		throw new Error("Method not implemented.");
+	}
+	public async getModificationTime(_path: RelativePath): Promise<Date> {
+		throw new Error("Method not implemented.");
+	}
+	public async exists(path: RelativePath): Promise<boolean> {
+		return this.names.has(path);
+	}
+	public async createDirectory(_path: RelativePath): Promise<void> {
+		// this is called but irrelevant for this mock
+	}
+	public async delete(_path: RelativePath): Promise<void> {
+		throw new Error("Method not implemented.");
+	}
+	public async rename(
+		oldPath: RelativePath,
+		newPath: RelativePath
+	): Promise<void> {
+		this.names.delete(oldPath);
+		this.names.add(newPath);
+	}
+}
 
 describe("File operations", () => {
-	class MockDatabase implements Partial<Database> {
+	beforeEach(async () => {
-		public getLatestDocumentByRelativePath(
+		const wasmBin = fs.readFileSync(
-			_find: RelativePath
+			"../../backend/sync_lib/pkg/sync_lib_bg.wasm"
-		): DocumentRecord | undefined {
+		);
-			// no-op
+		await init({ module_or_path: wasmBin });
-			return undefined;
+	});
-		}
 
-		public move(
+	it("should deconflict renames", async () => {
-			_oldRelativePath: RelativePath,
+		const fileSystemOperations = new FakeFileSystemOperations();
-			_newRelativePath: RelativePath
-		): void {
-			// no-op
-		}
-	}
-
-	class FakeFileSystemOperations implements FileSystemOperations {
-		public readonly names = new Set<string>();
-
-		public async listAllFiles(): Promise<RelativePath[]> {
-			throw new Error("Method not implemented.");
-		}
-		public async read(_path: RelativePath): Promise<Uint8Array> {
-			throw new Error("Method not implemented.");
-		}
-		public async write(
-			path: RelativePath,
-			_content: Uint8Array
-		): Promise<void> {
-			this.names.add(path);
-		}
-		public async atomicUpdateText(
-			_path: RelativePath,
-			_updater: (currentContent: string) => string
-		): Promise<string> {
-			throw new Error("Method not implemented.");
-		}
-		public async getFileSize(_path: RelativePath): Promise<number> {
-			throw new Error("Method not implemented.");
-		}
-		public async getModificationTime(_path: RelativePath): Promise<Date> {
-			throw new Error("Method not implemented.");
-		}
-		public async exists(path: RelativePath): Promise<boolean> {
-			return this.names.has(path);
-		}
-		public async createDirectory(_path: RelativePath): Promise<void> {
-			// this is called but irrelevant for this mock
-		}
-		public async delete(_path: RelativePath): Promise<void> {
-			throw new Error("Method not implemented.");
-		}
-		public async rename(
-			oldPath: RelativePath,
-			newPath: RelativePath
-		): Promise<void> {
-			this.names.delete(oldPath);
-			this.names.add(newPath);
-		}
-	}
-
-	test("should deconflict renames", async () => {
-		const fs = new FakeFileSystemOperations();
 		const fileOperations = new FileOperations(
 			new Logger(),
 			new MockDatabase() as Database, // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
-			fs
+			fileSystemOperations
 		);
 
 		await fileOperations.create("a", new Uint8Array());
-		assertSetContainsExactly(fs.names, "a");
+		assertSetContainsExactly(fileSystemOperations.names, "a");
 		await fileOperations.move("a", "b");
-		assertSetContainsExactly(fs.names, "b");
+		assertSetContainsExactly(fileSystemOperations.names, "b");
 
 		await fileOperations.create("c", new Uint8Array());
-		assertSetContainsExactly(fs.names, "b", "c");
+		assertSetContainsExactly(fileSystemOperations.names, "b", "c");
 
 		await fileOperations.move("c", "b");
-		assertSetContainsExactly(fs.names, "b", "b (1)");
+		assertSetContainsExactly(fileSystemOperations.names, "b", "b (1)");
 
 		await fileOperations.create("c", new Uint8Array());
 		await fileOperations.move("c", "b");
-		assertSetContainsExactly(fs.names, "b", "b (1)", "b (2)");
+		assertSetContainsExactly(
+			fileSystemOperations.names,
+			"b",
+			"b (1)",
+			"b (2)"
+		);
 	});
 
-	test("should deconflict renames with file extension", async () => {
+	it("should deconflict renames with file extension", async () => {
 		const fs = new FakeFileSystemOperations();
 		const fileOperations = new FileOperations(
 			new Logger(),
@@ -124,7 +138,7 @@ describe("File operations", () => {
 		);
 	});
 
-	test("should deconflict renames with paths", async () => {
+	it("should deconflict renames with paths", async () => {
 		const fs = new FakeFileSystemOperations();
 		const fileOperations = new FileOperations(
 			new Logger(),