Andras Schmelczer
9d99a4ac23
Move error classes from services/ and file-operations/ into a new errors/ directory (authentication-error, server-version-mismatch-error, sync-reset-error, file-not-found-error), plus add file-already-exists-error and http-client-error. Update consts.ts and utils/* (await-all, create-client-id, hash, rate-limit, find-matching-file). Replace data-structures (locks, min-covered, event-listeners, fix-sized-cache) and add debugging utilities (in-memory-file-system, log-to-console, slow-web-socket-factory). Removes utils/create-promise.ts.
339 lines
11 KiB
TypeScript
339 lines
11 KiB
TypeScript
import { describe, it, beforeEach } from "node:test";
|
|
import assert from "node:assert";
|
|
import { Logger } from "../../tracing/logger";
|
|
import type { RelativePath } from "../../sync-operations/types";
|
|
import { Locks } from "./locks";
|
|
import { awaitAll } from "../await-all";
|
|
import { sleep } from "../sleep";
|
|
import { SyncResetError } from "../../errors/sync-reset-error";
|
|
|
|
describe("withLock", () => {
|
|
const testPath: RelativePath = "test/document/path";
|
|
const testPath2: RelativePath = "test/document/path2";
|
|
const testPath3: RelativePath = "test/document/path3";
|
|
|
|
const logger = new Logger();
|
|
|
|
// eslint-disable-next-line @typescript-eslint/init-declarations
|
|
let locks: Locks<RelativePath>;
|
|
|
|
beforeEach(() => {
|
|
locks = new Locks<RelativePath>("locks-test", logger);
|
|
});
|
|
|
|
it("should execute function with single key lock", async () => {
|
|
let executionCount = 0;
|
|
const result = await locks.withLock(testPath, () => {
|
|
executionCount++;
|
|
return "success";
|
|
});
|
|
|
|
assert.strictEqual(result, "success");
|
|
assert.strictEqual(executionCount, 1);
|
|
});
|
|
|
|
it("should execute async function with single key lock", async () => {
|
|
let executionCount = 0;
|
|
const result = await locks.withLock(testPath, async () => {
|
|
executionCount++;
|
|
await sleep(10);
|
|
return "async-success";
|
|
});
|
|
|
|
assert.strictEqual(result, "async-success");
|
|
assert.strictEqual(executionCount, 1);
|
|
});
|
|
|
|
it("should execute function with multiple key locks", async () => {
|
|
let executionCount = 0;
|
|
const result = await locks.withLock([testPath, testPath2], () => {
|
|
executionCount++;
|
|
return "multi-success";
|
|
});
|
|
|
|
assert.strictEqual(result, "multi-success");
|
|
assert.strictEqual(executionCount, 1);
|
|
});
|
|
|
|
it("should sort multiple keys to prevent deadlocks", async () => {
|
|
const executionOrder: string[] = [];
|
|
|
|
await locks.waitForLock(testPath);
|
|
|
|
const promise = awaitAll([
|
|
locks.withLock([testPath2, testPath3, testPath], async () => {
|
|
executionOrder.push("operation1-start");
|
|
executionOrder.push("operation1-end");
|
|
return "result1";
|
|
}),
|
|
|
|
locks.withLock([testPath3, testPath, testPath2], async () => {
|
|
executionOrder.push("operation2-start");
|
|
executionOrder.push("operation2-end");
|
|
return "result2";
|
|
})
|
|
]);
|
|
|
|
locks.unlock(testPath);
|
|
|
|
const [result1, result2] = await Promise.race([
|
|
promise,
|
|
new Promise<never>((_, reject) => {
|
|
setTimeout(() => {
|
|
reject(new Error("Deadlock detected"));
|
|
}, 1000);
|
|
})
|
|
]);
|
|
|
|
assert.strictEqual(result1, "result1");
|
|
assert.strictEqual(result2, "result2");
|
|
// One operation should complete entirely before the other starts
|
|
assert.deepStrictEqual(executionOrder, [
|
|
"operation1-start",
|
|
"operation1-end",
|
|
"operation2-start",
|
|
"operation2-end"
|
|
]);
|
|
});
|
|
|
|
it("should serialize access to same key", async () => {
|
|
const executionOrder: string[] = [];
|
|
|
|
const promise1 = locks.withLock(testPath, async () => {
|
|
executionOrder.push("operation1-start");
|
|
await sleep(50);
|
|
executionOrder.push("operation1-end");
|
|
return "result1";
|
|
});
|
|
|
|
const promise2 = locks.withLock(testPath, async () => {
|
|
executionOrder.push("operation2-start");
|
|
await sleep(30);
|
|
executionOrder.push("operation2-end");
|
|
return "result2";
|
|
});
|
|
|
|
const [result1, result2] = await awaitAll([promise1, promise2]);
|
|
|
|
assert.strictEqual(result1, "result1");
|
|
assert.strictEqual(result2, "result2");
|
|
assert.deepStrictEqual(executionOrder, [
|
|
"operation1-start",
|
|
"operation1-end",
|
|
"operation2-start",
|
|
"operation2-end"
|
|
]);
|
|
});
|
|
|
|
it("should allow concurrent access to different keys", async () => {
|
|
const executionOrder: string[] = [];
|
|
|
|
const promise1 = locks.withLock(testPath, async () => {
|
|
executionOrder.push("operation1-start");
|
|
await sleep(50);
|
|
|
|
executionOrder.push("operation1-end");
|
|
return "result1";
|
|
});
|
|
|
|
const promise2 = locks.withLock(testPath2, async () => {
|
|
executionOrder.push("operation2-start");
|
|
await sleep(30);
|
|
executionOrder.push("operation2-end");
|
|
return "result2";
|
|
});
|
|
|
|
const [result1, result2] = await awaitAll([promise1, promise2]);
|
|
|
|
assert.strictEqual(result1, "result1");
|
|
assert.strictEqual(result2, "result2");
|
|
// Both operations should run concurrently
|
|
assert.strictEqual(executionOrder[0], "operation1-start");
|
|
assert.strictEqual(executionOrder[1], "operation2-start");
|
|
});
|
|
|
|
it("should release locks even if function throws", async () => {
|
|
const error = new Error("test error");
|
|
|
|
await assert.rejects(
|
|
locks.withLock(testPath, () => {
|
|
throw error;
|
|
}),
|
|
{ message: "test error" }
|
|
);
|
|
|
|
// Lock should be released, allowing another operation
|
|
const result = await locks.withLock(
|
|
testPath,
|
|
() => "success-after-error"
|
|
);
|
|
assert.strictEqual(result, "success-after-error");
|
|
});
|
|
|
|
it("should release locks even if async function throws", async () => {
|
|
const error = new Error("async test error");
|
|
|
|
await assert.rejects(
|
|
locks.withLock(testPath, async () => {
|
|
await sleep(10);
|
|
|
|
throw error;
|
|
}),
|
|
{ message: "async test error" }
|
|
);
|
|
|
|
// Lock should be released, allowing another operation
|
|
const result = await locks.withLock(
|
|
testPath,
|
|
() => "success-after-async-error"
|
|
);
|
|
assert.strictEqual(result, "success-after-async-error");
|
|
});
|
|
|
|
it("should handle empty array of keys", async () => {
|
|
const result = await locks.withLock([], () => "empty-keys");
|
|
assert.strictEqual(result, "empty-keys");
|
|
});
|
|
|
|
it("should maintain FIFO order for multiple waiters", async () => {
|
|
const executionOrder: string[] = [];
|
|
|
|
// Start first operation that holds the lock
|
|
const firstPromise = locks.withLock(testPath, async () => {
|
|
executionOrder.push("first-start");
|
|
await sleep(100);
|
|
executionOrder.push("first-end");
|
|
return "first";
|
|
});
|
|
|
|
// Small delay to ensure first operation starts
|
|
await sleep(10);
|
|
|
|
// Queue second and third operations
|
|
const secondPromise = locks.withLock(testPath, async () => {
|
|
executionOrder.push("second-start");
|
|
await sleep(50);
|
|
executionOrder.push("second-end");
|
|
return "second";
|
|
});
|
|
|
|
const thirdPromise = locks.withLock(testPath, async () => {
|
|
executionOrder.push("third-start");
|
|
await sleep(20);
|
|
executionOrder.push("third-end");
|
|
return "third";
|
|
});
|
|
|
|
const [first, second, third] = await awaitAll([
|
|
firstPromise,
|
|
secondPromise,
|
|
thirdPromise
|
|
]);
|
|
|
|
assert.strictEqual(first, "first");
|
|
assert.strictEqual(second, "second");
|
|
assert.strictEqual(third, "third");
|
|
assert.deepStrictEqual(executionOrder, [
|
|
"first-start",
|
|
"first-end",
|
|
"second-start",
|
|
"second-end",
|
|
"third-start",
|
|
"third-end"
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe("reset", () => {
|
|
const testPath: RelativePath = "test/document/path";
|
|
const testPath2: RelativePath = "test/document/path2";
|
|
const logger = new Logger();
|
|
|
|
// eslint-disable-next-line @typescript-eslint/init-declarations
|
|
let locks: Locks<RelativePath>;
|
|
|
|
beforeEach(() => {
|
|
locks = new Locks<RelativePath>("locks-test", logger);
|
|
});
|
|
|
|
it("should reject pending waiters with SyncResetError while running operation completes", async () => {
|
|
const firstPromise = locks.withLock(testPath, async () => {
|
|
await sleep(2);
|
|
return "first";
|
|
});
|
|
|
|
await sleep(1);
|
|
|
|
const secondPromise = locks.withLock(testPath, async () => "second");
|
|
void secondPromise.catch(() => {}); // eslint-disable-line @typescript-eslint/no-empty-function
|
|
|
|
locks.reset();
|
|
|
|
assert.strictEqual(await firstPromise, "first");
|
|
|
|
await assert.rejects(secondPromise, (err: Error) => {
|
|
assert.ok(err instanceof SyncResetError);
|
|
return true;
|
|
});
|
|
});
|
|
|
|
it("should allow locks to work normally after reset", async () => {
|
|
const firstPromise = locks.withLock(testPath, async () => {
|
|
await sleep(1);
|
|
return "first";
|
|
});
|
|
|
|
await sleep(1);
|
|
|
|
const secondPromise = locks.withLock(testPath, async () => "second");
|
|
void secondPromise.catch(() => {}); // eslint-disable-line @typescript-eslint/no-empty-function
|
|
|
|
locks.reset();
|
|
|
|
await firstPromise;
|
|
|
|
const result = await locks.withLock(testPath, () => "after-reset");
|
|
assert.strictEqual(result, "after-reset");
|
|
});
|
|
|
|
it("should handle reset with no pending operations", async () => {
|
|
locks.reset();
|
|
|
|
const result = await locks.withLock(testPath, () => "success");
|
|
assert.strictEqual(result, "success");
|
|
});
|
|
|
|
it("should release partially acquired locks when reset interrupts multi-key acquisition", async () => {
|
|
// Hold testPath2 so multi-key acquisition will block on it
|
|
await locks.waitForLock(testPath2);
|
|
|
|
// Start multi-key lock that will acquire testPath first, then block on testPath2
|
|
const multiKeyPromise = locks.withLock(
|
|
[testPath, testPath2],
|
|
async () => "multi"
|
|
);
|
|
void multiKeyPromise.catch(() => {}); // eslint-disable-line @typescript-eslint/no-empty-function
|
|
|
|
// Wait for the multi-key operation to acquire testPath and start waiting on testPath2
|
|
await sleep(10);
|
|
|
|
// Reset should reject the waiting operation
|
|
locks.reset();
|
|
|
|
await assert.rejects(multiKeyPromise, (err: Error) => {
|
|
assert.ok(err instanceof SyncResetError);
|
|
return true;
|
|
});
|
|
|
|
// The key that was already acquired (testPath) should now be released
|
|
// This would hang/timeout if the lock was leaked
|
|
const result = await Promise.race([
|
|
locks.withLock(testPath, () => "success"),
|
|
sleep(100).then(() => {
|
|
throw new Error("Lock was not released - deadlock detected");
|
|
})
|
|
]);
|
|
|
|
assert.strictEqual(result, "success");
|
|
});
|
|
});
|