177 lines
6.4 KiB
TypeScript
177 lines
6.4 KiB
TypeScript
import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
|
|
|
|
import { createDbClient } from "./client.server.js";
|
|
import { databaseTargetLabel, isDatabaseReachable } from "./database-reachable.js";
|
|
import {
|
|
OUTBOX_CLAIM_DEFAULT_LIMIT,
|
|
OUTBOX_CLAIM_LEASE_MS,
|
|
claimPendingOutboxEvents,
|
|
} from "./outbox-claim.js";
|
|
|
|
const DATABASE_URL = process.env.DATABASE_URL?.trim();
|
|
// Vitest setup defaults DATABASE_URL to example.invalid so unit tests do
|
|
// not need a live Postgres. Opt into the real Postgres integration suite
|
|
// by exporting `OUTBOX_TEST_DATABASE_URL` or by pointing DATABASE_URL at
|
|
// a real Postgres (anything that is not the vitest example.invalid stub).
|
|
const integrationUrl =
|
|
process.env.OUTBOX_TEST_DATABASE_URL?.trim() ||
|
|
(DATABASE_URL && !DATABASE_URL.includes("example.invalid") ? DATABASE_URL : undefined);
|
|
|
|
// A non-sentinel URL is necessary but not sufficient: the CI "Workspace
|
|
// package tests" job injects a localhost DATABASE_URL without running a
|
|
// Postgres service, so probe the server before connecting and skip (rather
|
|
// than fail with P1001) when nothing is reachable.
|
|
const databaseReachable = integrationUrl ? await isDatabaseReachable(integrationUrl) : false;
|
|
if (integrationUrl && !databaseReachable) {
|
|
console.warn(`[outbox-claim] skipped: no database reachable at ${databaseTargetLabel(integrationUrl)}`);
|
|
}
|
|
|
|
const describeIntegration = databaseReachable ? describe : describe.skip;
|
|
|
|
describeIntegration("claimPendingOutboxEvents (integration)", () => {
|
|
const prisma = createDbClient({ connectionString: integrationUrl });
|
|
|
|
beforeAll(async () => {
|
|
await prisma.$connect();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await prisma.outboxEvent.deleteMany({
|
|
where: { eventType: { startsWith: "test.claim." } },
|
|
});
|
|
await prisma.$disconnect();
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
await prisma.outboxEvent.deleteMany({
|
|
where: { eventType: { startsWith: "test.claim." } },
|
|
});
|
|
});
|
|
|
|
it("claims up to `limit` pending events and flips them to PROCESSING", async () => {
|
|
const now = new Date("2026-05-17T08:00:00.000Z");
|
|
const past = new Date(now.getTime() - 60 * 1000);
|
|
|
|
await prisma.outboxEvent.createMany({
|
|
data: [
|
|
{ eventType: "test.claim.alpha", payload: { i: 1 }, scheduledAt: past, priority: 0 },
|
|
{ eventType: "test.claim.alpha", payload: { i: 2 }, scheduledAt: past, priority: 5 },
|
|
{ eventType: "test.claim.alpha", payload: { i: 3 }, scheduledAt: past, priority: 5 },
|
|
],
|
|
});
|
|
|
|
const claimed = await claimPendingOutboxEvents(prisma, { limit: 2, now });
|
|
|
|
expect(claimed).toHaveLength(2);
|
|
for (const event of claimed) {
|
|
expect(event.status).toBe("PROCESSING");
|
|
expect(event.lockedUntil).not.toBeNull();
|
|
}
|
|
// Highest priority is dispatched first.
|
|
expect(claimed.map((event) => event.priority)).toEqual([5, 5]);
|
|
});
|
|
|
|
it("skips events whose scheduledAt is in the future", async () => {
|
|
const now = new Date("2026-05-17T08:00:00.000Z");
|
|
const past = new Date(now.getTime() - 60 * 1000);
|
|
const future = new Date(now.getTime() + 60 * 1000);
|
|
|
|
await prisma.outboxEvent.createMany({
|
|
data: [
|
|
{ eventType: "test.claim.scheduled", payload: { i: 1 }, scheduledAt: past },
|
|
{ eventType: "test.claim.scheduled", payload: { i: 2 }, scheduledAt: future },
|
|
],
|
|
});
|
|
|
|
const claimed = await claimPendingOutboxEvents(prisma, { now });
|
|
expect(claimed).toHaveLength(1);
|
|
expect((claimed[0]?.payload as { i: number }).i).toBe(1);
|
|
});
|
|
|
|
it("never claims the same event twice when two callers race", async () => {
|
|
const now = new Date("2026-05-17T08:00:00.000Z");
|
|
const past = new Date(now.getTime() - 60 * 1000);
|
|
|
|
await prisma.outboxEvent.createMany({
|
|
data: Array.from({ length: 20 }, (_, index) => ({
|
|
eventType: "test.claim.race",
|
|
payload: { i: index },
|
|
scheduledAt: past,
|
|
})),
|
|
});
|
|
|
|
const [batchA, batchB] = await Promise.all([
|
|
claimPendingOutboxEvents(prisma, { limit: 50, now }),
|
|
claimPendingOutboxEvents(prisma, { limit: 50, now }),
|
|
]);
|
|
|
|
const ids = new Set<string>();
|
|
for (const event of [...batchA, ...batchB]) {
|
|
expect(ids.has(event.id)).toBe(false);
|
|
ids.add(event.id);
|
|
}
|
|
expect(ids.size).toBe(20);
|
|
});
|
|
|
|
it("recovers events stuck in PROCESSING past their lease", async () => {
|
|
const now = new Date("2026-05-17T08:00:00.000Z");
|
|
const expired = new Date(now.getTime() - 60 * 1000);
|
|
|
|
const created = await prisma.outboxEvent.create({
|
|
data: {
|
|
eventType: "test.claim.recovery",
|
|
payload: { i: 1 },
|
|
status: "PROCESSING",
|
|
lockedUntil: expired,
|
|
},
|
|
});
|
|
|
|
const claimed = await claimPendingOutboxEvents(prisma, { now });
|
|
expect(claimed).toHaveLength(1);
|
|
expect(claimed[0]?.id).toBe(created.id);
|
|
});
|
|
|
|
it("does not touch FAILED or DONE rows", async () => {
|
|
const now = new Date("2026-05-17T08:00:00.000Z");
|
|
const past = new Date(now.getTime() - 60 * 1000);
|
|
await prisma.outboxEvent.createMany({
|
|
data: [
|
|
{ eventType: "test.claim.terminal", payload: { i: 1 }, status: "FAILED", scheduledAt: past },
|
|
{ eventType: "test.claim.terminal", payload: { i: 2 }, status: "DONE", scheduledAt: past },
|
|
],
|
|
});
|
|
|
|
const claimed = await claimPendingOutboxEvents(prisma, { now });
|
|
expect(claimed).toHaveLength(0);
|
|
});
|
|
|
|
it("exposes documented constants", () => {
|
|
expect(OUTBOX_CLAIM_DEFAULT_LIMIT).toBe(100);
|
|
expect(OUTBOX_CLAIM_LEASE_MS).toBe(5 * 60 * 1000);
|
|
});
|
|
});
|
|
|
|
describe("claimPendingOutboxEvents (unit fallback)", () => {
|
|
it("returns empty array when $queryRaw returns non-array", async () => {
|
|
const fakePrisma = {
|
|
$queryRaw: (async () => null) as unknown as import("./outbox-claim.js").OutboxClaimRunner["$queryRaw"],
|
|
};
|
|
const claimed = await claimPendingOutboxEvents(fakePrisma);
|
|
expect(claimed).toEqual([]);
|
|
});
|
|
|
|
it("clamps limit to the configured bounds", async () => {
|
|
const captured: Array<unknown> = [];
|
|
const fakePrisma = {
|
|
$queryRaw: (async (sql: unknown) => {
|
|
captured.push(sql);
|
|
return [];
|
|
}) as unknown as import("./outbox-claim.js").OutboxClaimRunner["$queryRaw"],
|
|
};
|
|
await claimPendingOutboxEvents(fakePrisma, { limit: 999_999 });
|
|
await claimPendingOutboxEvents(fakePrisma, { limit: -5 });
|
|
await claimPendingOutboxEvents(fakePrisma, { limit: Number.NaN });
|
|
expect(captured).toHaveLength(3);
|
|
});
|
|
});
|