Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/db/src/outbox-claim.test.ts
T
2026-07-08 16:15:37 +02:00

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);
});
});