116 lines
3.8 KiB
TypeScript
116 lines
3.8 KiB
TypeScript
import { describe, expect, test } from "bun:test";
|
|
import {
|
|
canUserBuild,
|
|
getBuildRateLimitStats,
|
|
recordBuildEnd,
|
|
recordBuildStart,
|
|
} from "./build-rate-limit";
|
|
|
|
// Module state is process-global. Each test uses a unique userId so concurrent
|
|
// or sequential tests don't leak state into each other, and always pairs every
|
|
// recordBuildStart with a recordBuildEnd in a try/finally to keep global counts
|
|
// clean for unrelated tests.
|
|
|
|
let nextUserId = 1_000_000;
|
|
function uniqueUser(): number {
|
|
nextUserId += 1;
|
|
return nextUserId;
|
|
}
|
|
|
|
describe("canUserBuild", () => {
|
|
test("allows a fresh user", () => {
|
|
expect(canUserBuild(uniqueUser())).toEqual({ allowed: true });
|
|
});
|
|
|
|
test("blocks user once their per-user concurrent limit is reached", () => {
|
|
const userId = uniqueUser();
|
|
const started: number[] = [];
|
|
try {
|
|
// Saturate the per-user concurrent slot (default config: 1).
|
|
while (true) {
|
|
const decision = canUserBuild(userId);
|
|
if (!decision.allowed) break;
|
|
recordBuildStart(userId);
|
|
started.push(userId);
|
|
if (started.length > 20) throw new Error("unexpected: never hit per-user cap");
|
|
}
|
|
const blocked = canUserBuild(userId);
|
|
expect(blocked.allowed).toBe(false);
|
|
expect(blocked.reason).toMatch(/concurrent per user/i);
|
|
} finally {
|
|
for (const u of started) recordBuildEnd(u);
|
|
}
|
|
});
|
|
|
|
test("releases the slot after recordBuildEnd", () => {
|
|
const userId = uniqueUser();
|
|
recordBuildStart(userId);
|
|
try {
|
|
const mid = canUserBuild(userId);
|
|
// May be blocked depending on per-user cap; either way recordBuildEnd must restore capacity.
|
|
if (!mid.allowed) {
|
|
recordBuildEnd(userId);
|
|
expect(canUserBuild(userId).allowed).toBe(true);
|
|
// Re-start so the finally block's recordBuildEnd matches a started build.
|
|
recordBuildStart(userId);
|
|
}
|
|
} finally {
|
|
recordBuildEnd(userId);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("recordBuildStart / recordBuildEnd", () => {
|
|
test("globalActive increases then decreases symmetrically", () => {
|
|
const userId = uniqueUser();
|
|
const before = getBuildRateLimitStats().globalActive;
|
|
recordBuildStart(userId);
|
|
try {
|
|
expect(getBuildRateLimitStats().globalActive).toBe(before + 1);
|
|
} finally {
|
|
recordBuildEnd(userId);
|
|
}
|
|
expect(getBuildRateLimitStats().globalActive).toBe(before);
|
|
});
|
|
|
|
test("recordBuildEnd on a user with no active builds does not underflow", () => {
|
|
const userId = uniqueUser();
|
|
const before = getBuildRateLimitStats().globalActive;
|
|
// No matching start. Should be a no-op for global count.
|
|
recordBuildEnd(userId);
|
|
expect(getBuildRateLimitStats().globalActive).toBe(before);
|
|
});
|
|
|
|
test("multiple starts accumulate active count per user", () => {
|
|
const userId = uniqueUser();
|
|
recordBuildStart(userId);
|
|
recordBuildStart(userId);
|
|
try {
|
|
const stats = getBuildRateLimitStats();
|
|
const entry = stats.perUser.find((u) => u.userId === userId);
|
|
expect(entry).toBeDefined();
|
|
expect(entry!.active).toBe(2);
|
|
expect(entry!.recentCount).toBe(2);
|
|
} finally {
|
|
recordBuildEnd(userId);
|
|
recordBuildEnd(userId);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("getBuildRateLimitStats", () => {
|
|
test("omits users with no recent or active builds", () => {
|
|
const userId = uniqueUser();
|
|
recordBuildStart(userId);
|
|
recordBuildEnd(userId);
|
|
// Without waiting an hour the timestamp is still 'recent', so the entry stays —
|
|
// but stats should still report it as active=0 if anything is reported at all.
|
|
const stats = getBuildRateLimitStats();
|
|
const entry = stats.perUser.find((u) => u.userId === userId);
|
|
if (entry) {
|
|
expect(entry.active).toBe(0);
|
|
expect(entry.recentCount).toBeGreaterThan(0);
|
|
}
|
|
});
|
|
});
|