Files
clean-architecture-frontend…/tests/platform/traffic/concurrency-budget.test.ts
T

95 lines
3.0 KiB
TypeScript

import { describe, expect, it } from "vitest";
import {
ConcurrencyQueueFullError,
createConcurrencyBudget,
} from "../../../src/platform/traffic/concurrency-budget.ts";
const live = () => new AbortController().signal;
describe("createConcurrencyBudget", () => {
it("never grants more than maximum simultaneous leases", async () => {
const budget = createConcurrencyBudget({ maximum: 2, maxQueued: 1 });
const first = await budget.acquire(live());
const second = await budget.acquire(live());
expect(budget.active).toBe(2);
const queued = budget.acquire(live());
expect(budget.queued).toBe(1);
await expect(budget.acquire(live())).rejects.toThrow(/queue/i);
await expect(budget.acquire(live())).rejects.toBeInstanceOf(
ConcurrencyQueueFullError,
);
first.release();
const third = await queued;
expect(budget.active).toBe(2);
second.release();
third.release();
expect(budget.active).toBe(0);
});
it("removes an aborted waiter", async () => {
const budget = createConcurrencyBudget({ maximum: 1, maxQueued: 1 });
const lease = await budget.acquire(live());
const controller = new AbortController();
const waiting = budget.acquire(controller.signal);
controller.abort();
await expect(waiting).rejects.toMatchObject({ name: "AbortError" });
expect(budget.queued).toBe(0);
lease.release();
expect(budget.active).toBe(0);
});
it("rejects immediately when the signal is already aborted", async () => {
const budget = createConcurrencyBudget({ maximum: 1, maxQueued: 1 });
const controller = new AbortController();
controller.abort();
await expect(budget.acquire(controller.signal)).rejects.toMatchObject({
name: "AbortError",
});
expect(budget.active).toBe(0);
});
it("grants waiters in FIFO order", async () => {
const budget = createConcurrencyBudget({ maximum: 1, maxQueued: 3 });
const holder = await budget.acquire(live());
const order: string[] = [];
const a = budget.acquire(live()).then((lease) => {
order.push("a");
return lease;
});
const b = budget.acquire(live()).then((lease) => {
order.push("b");
return lease;
});
holder.release();
(await a).release();
(await b).release();
expect(order).toEqual(["a", "b"]);
});
it("treats release as idempotent", async () => {
const budget = createConcurrencyBudget({ maximum: 1, maxQueued: 0 });
const lease = await budget.acquire(live());
lease.release();
lease.release();
expect(budget.active).toBe(0);
const again = await budget.acquire(live());
await expect(budget.acquire(live())).rejects.toBeInstanceOf(
ConcurrencyQueueFullError,
);
again.release();
});
it("rejects an unbounded configuration", () => {
expect(() =>
createConcurrencyBudget({ maximum: 1, maxQueued: Number.POSITIVE_INFINITY }),
).toThrow(TypeError);
expect(() => createConcurrencyBudget({ maximum: 0, maxQueued: 1 })).toThrow(
TypeError,
);
});
});