Log inside locks

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

@@ -0,0 +1,93 @@
+import { Logger } from "../tracing/logger";
+import type { RelativePath } from "../persistence/database";
+import { DocumentLocks } from "./document-locks";
+
+describe("Document lock", () => {
+	const testPath: RelativePath = "test/document/path";
+	const logger = new Logger();
+	let locks = new DocumentLocks(logger);
+
+	beforeEach(() => {
+		locks = new DocumentLocks(logger);
+	});
+
+	test("should lock a document successfully", () => {
+		const result = locks.tryLockDocument(testPath);
+		expect(result).toBe(true);
+	});
+
+	test("should not lock a document that is already locked", () => {
+		locks.tryLockDocument(testPath);
+		const result = locks.tryLockDocument(testPath);
+		expect(result).toBe(false);
+	});
+
+	test("should unlock a locked document", () => {
+		locks.tryLockDocument(testPath);
+		locks.unlockDocument(testPath);
+		const result = locks.tryLockDocument(testPath);
+		expect(result).toBe(true);
+		locks.unlockDocument(testPath);
+	});
+
+	test("should throw an error when unlocking a document that is not locked", () => {
+		expect(() => {
+			locks.unlockDocument(testPath);
+		}).toThrow(`Document ${testPath} is not locked, cannot unlock`);
+	});
+
+	test("should wait for a document lock and resolve when unlocked", async () => {
+		locks.tryLockDocument(testPath);
+
+		let resolved = false;
+		const waitPromise = locks.waitForDocumentLock(testPath).then(() => {
+			resolved = true;
+		});
+
+		locks.unlockDocument(testPath);
+		await waitPromise;
+
+		expect(resolved).toBe(true);
+	});
+
+	test("should resolve multiple waiters in FIFO order", async () => {
+		locks.tryLockDocument(testPath);
+
+		let firstResolved = false;
+		let secondResolved = false;
+		let thirdResolved = false;
+
+		const firstWaitPromise = locks
+			.waitForDocumentLock(testPath)
+			.then(() => {
+				firstResolved = true;
+			});
+
+		const secondWaitPromise = locks
+			.waitForDocumentLock(testPath)
+			.then(() => {
+				secondResolved = true;
+			});
+
+		const thirdWaitPromise = locks
+			.waitForDocumentLock(testPath)
+			.then(() => {
+				thirdResolved = true;
+			});
+
+		locks.unlockDocument(testPath);
+		await firstWaitPromise;
+		expect(firstResolved).toBe(true);
+		expect(secondResolved).toBe(false);
+		expect(thirdResolved).toBe(false);
+
+		locks.unlockDocument(testPath);
+		await secondWaitPromise;
+		expect(secondResolved).toBe(true);
+		expect(thirdResolved).toBe(false);
+
+		locks.unlockDocument(testPath);
+		await thirdWaitPromise;
+		expect(thirdResolved).toBe(true);
+	});
+});