import { assert, describe, it } from "@effect/vitest";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as Queue from "effect/Queue";
import * as Ref from "effect/Ref";
import * as Scope from "effect/Scope";
import * as KeyedLock from "./KeyedLock.ts";
describe("KeyedLock", () => {
it.effect("runs one holder of a key at a time, waiters in the order they queued", () =>
Effect.gen(function* () {
const lock = yield* KeyedLock.make<string>();
const events = yield* Ref.make<ReadonlyArray<string>>([]);
const record = (event: string) => Ref.update(events, (current) => [...current, event]);
const firstEntered = yield* Deferred.make<void>();
const releaseFirst = yield* Deferred.make<void>();
const first = yield* lock
.withLock(
"key",
record("first:start").pipe(
Effect.andThen(Deferred.succeed(firstEntered, undefined)),
Effect.andThen(Deferred.await(releaseFirst)),
Effect.andThen(record("first:end")),
),
)
.pipe(Effect.forkChild);
yield* Deferred.await(firstEntered);
const second = yield* lock.withLock("key", record("second")).pipe(Effect.forkChild);
const third = yield* lock.withLock("key", record("third")).pipe(Effect.forkChild);
yield* Effect.yieldNow;
assert.deepStrictEqual(yield* Ref.get(events), ["first:start"]);
yield* Deferred.succeed(releaseFirst, undefined);
yield* Fiber.joinAll([first, second, third]);
assert.deepStrictEqual(yield* Ref.get(events), [
"first:start",
"first:end",
"second",
"third",
]);
}),
);
it.effect("runs holders of different keys concurrently", () =>
Effect.gen(function* () {
const lock = yield* KeyedLock.make<string>();
const entered = yield* Queue.unbounded<string>();
const release = yield* Deferred.make<void>();
const hold = (key: string) =>
lock.withLock(key, Queue.offer(entered, key).pipe(Effect.andThen(Deferred.await(release))));
const holders = yield* Effect.forEach(["a", "b"], hold, { concurrency: "unbounded" }).pipe(
Effect.forkChild,
);
const both = new Set([yield* Queue.take(entered), yield* Queue.take(entered)]);
assert.deepStrictEqual(both, new Set(["a", "b"]));
yield* Deferred.succeed(release, undefined);
yield* Fiber.join(holders);
}),
);
it.effect("keeps no lock for a key once its holders and waiters are gone", () =>
Effect.gen(function* () {
const lock = yield* KeyedLock.make<string>();
const entered = yield* Deferred.make<void>();
const release = yield* Deferred.make<void>();
const holder = yield* lock
.withLock(
"key",
Deferred.succeed(entered, undefined).pipe(Effect.andThen(Deferred.await(release))),
)
.pipe(Effect.forkChild);
yield* Deferred.await(entered);
const abandoned = yield* lock.withLock("key", Effect.void).pipe(Effect.forkChild);
const waiting = yield* lock.withLock("key", Effect.void).pipe(Effect.forkChild);
yield* Effect.yieldNow;
assert.deepStrictEqual(yield* lock.activeKeys, ["key"]);
yield* Fiber.interrupt(abandoned);
assert.deepStrictEqual(yield* lock.activeKeys, ["key"]);
yield* Deferred.succeed(release, undefined);
yield* Fiber.joinAll([holder, waiting]);
assert.strictEqual(
yield* lock.withLock("other", Effect.fail("boom")).pipe(Effect.flip),
"boom",
);
assert.deepStrictEqual(yield* lock.activeKeys, []);
}),
);
it.effect("runs the effect in the caller's scope", () =>
Effect.gen(function* () {
const lock = yield* KeyedLock.make<string>();
const finalized = yield* Ref.make(false);
const callerScope = yield* Scope.make();
yield* lock
.withLock(
"key",
Effect.addFinalizer(() => Ref.set(finalized, true)),
)
.pipe(Scope.provide(callerScope));
assert.isFalse(yield* Ref.get(finalized));
yield* Scope.close(callerScope, Exit.void);
assert.isTrue(yield* Ref.get(finalized));
}),
);
});