@blokjs/trigger-worker 0.6.17 → 0.6.19

package/__tests__/integration/rabbitmq-adapter.real-rabbitmq.test.ts

@@ -1,179 +0,0 @@
-import type { WorkerJob } from "@blokjs/runner";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { RabbitMQAdapter } from "../../src/adapters/RabbitMQAdapter";
-
-/**
- * Real-RabbitMQ integration test for `RabbitMQAdapter` (closes Phase 2.1
- * broker-adapter test debt deferred from PR #91).
- *
- * Exercises the worker contract end-to-end against a real broker: queue
- * declaration, job add, consume + ack, isolation across queues, manual
- * `complete()` / `fail()` paths.
- *
- * Gated on `BLOK_INTEGRATION_RABBITMQ_URL`. Skipped when unset.
- *
- * Bring up the test fixtures via:
- *   docker compose -f infra/testing/docker-compose.yml up -d rabbitmq
- *
- * Then run:
- *   BLOK_INTEGRATION_RABBITMQ_URL=amqp://blok:blok_test@localhost:5673 bun run test
- */
-
-const RABBITMQ_URL = process.env.BLOK_INTEGRATION_RABBITMQ_URL;
-const d = RABBITMQ_URL ? describe : describe.skip;
-
-const TEST_TIMEOUT_MS = 30_000;
-
-d("RabbitMQAdapter — real RabbitMQ", () => {
-	let adapter: RabbitMQAdapter;
-
-	beforeAll(async () => {
-		adapter = new RabbitMQAdapter({ url: RABBITMQ_URL });
-		await adapter.connect();
-	}, TEST_TIMEOUT_MS);
-
-	afterAll(async () => {
-		await adapter.disconnect();
-	});
-
-	it(
-		"publishes a job and the consumer receives it (single-queue happy path)",
-		async () => {
-			// Random queue name per run so this test is idempotent against
-			// a long-lived broker — orphan messages from a prior crashed run
-			// wouldn't bleed into the count assertion below.
-			const queue = `blok-test-q-publish-${Math.random().toString(36).slice(2)}`;
-			const received: WorkerJob[] = [];
-
-			await adapter.process({ queue }, async (job) => {
-				received.push(job);
-				await job.complete();
-			});
-
-			const jobId = await adapter.addJob(queue, { hello: "world", n: 1 });
-			expect(typeof jobId).toBe("string");
-			expect(jobId).toBeTruthy();
-
-			await waitFor(() => received.length === 1, TEST_TIMEOUT_MS - 5_000);
-
-			expect(received).toHaveLength(1);
-			expect(received[0].data).toEqual({ hello: "world", n: 1 });
-			expect(received[0].queue).toBe(queue);
-			expect(received[0].id).toBeTruthy();
-
-			await adapter.stopProcessing(queue);
-		},
-		TEST_TIMEOUT_MS,
-	);
-
-	it(
-		"isolates jobs across distinct queues",
-		async () => {
-			const queueA = `blok-test-q-a-${Math.random().toString(36).slice(2)}`;
-			const queueB = `blok-test-q-b-${Math.random().toString(36).slice(2)}`;
-			const receivedA: WorkerJob[] = [];
-			const receivedB: WorkerJob[] = [];
-
-			await adapter.process({ queue: queueA }, async (job) => {
-				receivedA.push(job);
-				await job.complete();
-			});
-			await adapter.process({ queue: queueB }, async (job) => {
-				receivedB.push(job);
-				await job.complete();
-			});
-
-			await adapter.addJob(queueA, { from: "A" });
-			await adapter.addJob(queueB, { from: "B" });
-
-			await waitFor(() => receivedA.length === 1 && receivedB.length === 1, TEST_TIMEOUT_MS - 5_000);
-
-			expect(receivedA[0].data).toEqual({ from: "A" });
-			expect(receivedB[0].data).toEqual({ from: "B" });
-			expect(receivedA[0].queue).toBe(queueA);
-			expect(receivedB[0].queue).toBe(queueB);
-
-			await adapter.stopProcessing(queueA);
-			await adapter.stopProcessing(queueB);
-		},
-		TEST_TIMEOUT_MS,
-	);
-
-	it(
-		"delivers multiple jobs in order on a single-consumer queue",
-		async () => {
-			// Single consumer + prefetch(1) (the adapter's default for
-			// non-concurrent processing) preserves FIFO order. With multiple
-			// consumers Rabbit doesn't guarantee global order, so we keep
-			// this test narrow to single-consumer semantics.
-			const queue = `blok-test-q-order-${Math.random().toString(36).slice(2)}`;
-			const received: number[] = [];
-
-			await adapter.process({ queue }, async (job) => {
-				const data = job.data as { n: number };
-				received.push(data.n);
-				await job.complete();
-			});
-
-			for (let i = 0; i < 5; i++) {
-				await adapter.addJob(queue, { n: i });
-			}
-
-			await waitFor(() => received.length === 5, TEST_TIMEOUT_MS - 5_000);
-
-			expect(received).toEqual([0, 1, 2, 3, 4]);
-
-			await adapter.stopProcessing(queue);
-		},
-		TEST_TIMEOUT_MS,
-	);
-
-	it(
-		"failed jobs requeue when retries remain (manual fail path)",
-		async () => {
-			// Adapter NACK-with-requeue contract: the same job message is
-			// re-delivered after `fail()` until the retry budget is hit.
-			// We assert one re-delivery here; the full retry-budget DLQ
-			// flow is exercised by the adapter unit tests.
-			const queue = `blok-test-q-retry-${Math.random().toString(36).slice(2)}`;
-			let attempts = 0;
-			let firstAttemptId = "";
-
-			await adapter.process({ queue, retries: 1 }, async (job) => {
-				attempts++;
-				if (attempts === 1) {
-					firstAttemptId = job.id;
-					await job.fail(new Error("simulated transient failure"));
-					return;
-				}
-				// Second delivery: ack so we exit cleanly.
-				expect(job.id).toBe(firstAttemptId);
-				await job.complete();
-			});
-
-			await adapter.addJob(queue, { will_retry: true });
-
-			await waitFor(() => attempts >= 2, TEST_TIMEOUT_MS - 5_000);
-
-			expect(attempts).toBeGreaterThanOrEqual(2);
-
-			await adapter.stopProcessing(queue);
-		},
-		TEST_TIMEOUT_MS,
-	);
-
-	it("isConnected + healthCheck reflect the live state", async () => {
-		expect(adapter.isConnected()).toBe(true);
-		const healthy = await adapter.healthCheck();
-		expect(healthy).toBe(true);
-	});
-});
-
-async function waitFor(predicate: () => boolean, timeoutMs: number): Promise<void> {
-	const start = Date.now();
-	while (Date.now() - start < timeoutMs) {
-		if (predicate()) return;
-		await new Promise((r) => setTimeout(r, 50));
-	}
-	throw new Error(`waitFor timed out after ${timeoutMs}ms`);
-}

package/__tests__/integration/sqs-adapter.real-sqs.test.ts

@@ -1,228 +0,0 @@
-import type { WorkerJob } from "@blokjs/runner";
-import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
-import { SQSAdapter } from "../../src/adapters/SQSAdapter";
-
-/**
- * Real-LocalStack-SQS integration test for `SQSAdapter` (closes Phase 2.1
- * broker-adapter test debt deferred from PR #91).
- *
- * Gated on `BLOK_INTEGRATION_SQS_ENDPOINT`. Skipped when unset.
- *
- * Bring up the test fixtures via:
- *   docker compose -f infra/testing/docker-compose.yml up -d localstack
- *
- * Then run:
- *   BLOK_INTEGRATION_SQS_ENDPOINT=http://localhost:4567 \
- *   AWS_REGION=us-east-1 \
- *   AWS_ACCESS_KEY_ID=test \
- *   AWS_SECRET_ACCESS_KEY=test \
- *   bun run test
- */
-
-const SQS_ENDPOINT = process.env.BLOK_INTEGRATION_SQS_ENDPOINT;
-const d = SQS_ENDPOINT ? describe : describe.skip;
-
-const TEST_TIMEOUT_MS = 30_000;
-
-/**
- * Narrow shape for the LocalStack CreateQueue / DeleteQueue paths we
- * touch from this test only. Keeps us off `any` per the repo's
- * no-`any`-in-tests rule.
- */
-interface SqsTestClient {
-	send(cmd: unknown): Promise<{ QueueUrl?: string }>;
-	destroy?: () => void;
-}
-
-interface SqsCommands {
-	SQSClient: new (opts: { region: string; endpoint?: string }) => SqsTestClient;
-	CreateQueueCommand: new (opts: { QueueName: string }) => unknown;
-	DeleteQueueCommand: new (opts: { QueueUrl: string }) => unknown;
-}
-
-d("SQSAdapter — real LocalStack SQS", () => {
-	let adapter: SQSAdapter;
-	let testClient: SqsTestClient | null = null;
-	let sqsCommands: SqsCommands | null = null;
-	const createdQueues: string[] = [];
-
-	// LocalStack accepts any credentials; we set explicit ones so the SDK
-	// doesn't crawl the local environment / IMDS searching for them and
-	// time out the first request.
-	const TEST_REGION = process.env.AWS_REGION || "us-east-1";
-
-	async function createQueue(name: string): Promise<string> {
-		if (!testClient || !sqsCommands) throw new Error("test client not initialised — beforeAll didn't run");
-		const result = await testClient.send(new sqsCommands.CreateQueueCommand({ QueueName: name }));
-		const url = result.QueueUrl;
-		if (!url) throw new Error(`CreateQueue returned no QueueUrl for ${name}`);
-		createdQueues.push(url);
-		return url;
-	}
-
-	beforeAll(async () => {
-		// Force credentials BEFORE the SDK import — LocalStack rejects
-		// requests without any signature, and the default credential chain
-		// times out the first call when nothing is configured.
-		process.env.AWS_ACCESS_KEY_ID = process.env.AWS_ACCESS_KEY_ID || "test";
-		process.env.AWS_SECRET_ACCESS_KEY = process.env.AWS_SECRET_ACCESS_KEY || "test";
-		process.env.AWS_REGION = TEST_REGION;
-
-		adapter = new SQSAdapter({
-			region: TEST_REGION,
-			endpoint: SQS_ENDPOINT,
-			waitTimeSeconds: 1, // short long-poll so afterEach cleanup is responsive
-		});
-		await adapter.connect();
-
-		// Direct SDK client for queue management — we only need
-		// CreateQueue / DeleteQueue, the adapter doesn't expose those.
-		const sdk = (await import("@aws-sdk/client-sqs")) as unknown as SqsCommands;
-		sqsCommands = sdk;
-		testClient = new sdk.SQSClient({ region: TEST_REGION, endpoint: SQS_ENDPOINT });
-	}, TEST_TIMEOUT_MS);
-
-	afterEach(async () => {
-		// Tear down per-test queues so a flaky test doesn't poison the
-		// next one with redelivered messages.
-		for (const url of createdQueues.splice(0)) {
-			if (!testClient || !sqsCommands) continue;
-			try {
-				await testClient.send(new sqsCommands.DeleteQueueCommand({ QueueUrl: url }));
-			} catch {
-				/* ignore — best-effort cleanup */
-			}
-		}
-	});
-
-	afterAll(async () => {
-		await adapter.disconnect();
-		testClient?.destroy?.();
-	});
-
-	it(
-		"publishes a job and the consumer receives it (single-queue happy path)",
-		async () => {
-			const queueUrl = await createQueue(`blok-test-sqs-publish-${Math.random().toString(36).slice(2)}`);
-			const received: WorkerJob[] = [];
-
-			await adapter.process({ queue: queueUrl }, async (job) => {
-				received.push(job);
-				await job.complete();
-			});
-
-			const jobId = await adapter.addJob(queueUrl, { hello: "sqs", n: 1 });
-			expect(typeof jobId).toBe("string");
-
-			await waitFor(() => received.length === 1, TEST_TIMEOUT_MS - 5_000);
-
-			expect(received[0].data).toEqual({ hello: "sqs", n: 1 });
-			expect(received[0].queue).toBe(queueUrl);
-
-			await adapter.stopProcessing(queueUrl);
-		},
-		TEST_TIMEOUT_MS,
-	);
-
-	it(
-		"isolates jobs across distinct queues",
-		async () => {
-			const queueA = await createQueue(`blok-test-sqs-a-${Math.random().toString(36).slice(2)}`);
-			const queueB = await createQueue(`blok-test-sqs-b-${Math.random().toString(36).slice(2)}`);
-			const receivedA: WorkerJob[] = [];
-			const receivedB: WorkerJob[] = [];
-
-			await adapter.process({ queue: queueA }, async (job) => {
-				receivedA.push(job);
-				await job.complete();
-			});
-			await adapter.process({ queue: queueB }, async (job) => {
-				receivedB.push(job);
-				await job.complete();
-			});
-
-			await adapter.addJob(queueA, { from: "A" });
-			await adapter.addJob(queueB, { from: "B" });
-
-			await waitFor(() => receivedA.length === 1 && receivedB.length === 1, TEST_TIMEOUT_MS - 5_000);
-
-			expect(receivedA[0].data).toEqual({ from: "A" });
-			expect(receivedB[0].data).toEqual({ from: "B" });
-
-			await adapter.stopProcessing(queueA);
-			await adapter.stopProcessing(queueB);
-		},
-		TEST_TIMEOUT_MS,
-	);
-
-	it(
-		"handler that calls fail() does NOT delete the message — visibility timeout returns it",
-		async () => {
-			// Direct exercise of the v0.5 settle-once fix in SQSAdapter:
-			// before the fix, the wrapper auto-deleted after the handler
-			// returned, so `fail()` was a no-op. After: `fail()` settles
-			// the job and the wrapper skips delete; SQS's visibility
-			// timeout (default 30s) eventually re-delivers the message.
-			//
-			// We don't WAIT for the redelivery here — that would hang for
-			// 30s. We assert the message is still IN FLIGHT (active count
-			// or ApproximateNumberOfMessagesNotVisible > 0) right after
-			// fail() resolves. Or, more reliably: re-receive the same
-			// message after a short visibility-timeout override via
-			// SetQueueAttributes / ChangeMessageVisibility — but that adds
-			// noise. The test below just asserts `fail()` doesn't throw
-			// and the wrapper auto-delete path is suppressed.
-			const queueUrl = await createQueue(`blok-test-sqs-fail-${Math.random().toString(36).slice(2)}`);
-			let failCalls = 0;
-			let acks = 0;
-
-			await adapter.process(
-				{
-					queue: queueUrl,
-					retries: 0,
-					timeout: 60_000, // give SQS time before redelivery so we don't loop
-				},
-				async (job) => {
-					if (failCalls === 0) {
-						failCalls += 1;
-						await job.fail(new Error("simulated failure"));
-						return;
-					}
-					acks += 1;
-					await job.complete();
-				},
-			);
-
-			await adapter.addJob(queueUrl, { will_fail: true });
-
-			await waitFor(() => failCalls === 1, TEST_TIMEOUT_MS - 5_000);
-
-			// The wrapper must NOT have auto-deleted; if it did, `acks`
-			// could stay 0 forever, but more importantly `failCalls` is
-			// the correctness signal — fail() ran without throwing.
-			expect(failCalls).toBe(1);
-			// `acks` is 0 within our window because SQS's visibility
-			// timeout hasn't elapsed yet; that's expected — we're only
-			// verifying fail() doesn't crash and doesn't auto-ack.
-			expect(acks).toBe(0);
-
-			await adapter.stopProcessing(queueUrl);
-		},
-		TEST_TIMEOUT_MS,
-	);
-
-	it("isConnected + healthCheck reflect the live state", async () => {
-		expect(adapter.isConnected()).toBe(true);
-		const healthy = await adapter.healthCheck();
-		expect(healthy).toBe(true);
-	});
-});
-
-async function waitFor(predicate: () => boolean, timeoutMs: number): Promise<void> {
-	const start = Date.now();
-	while (Date.now() - start < timeoutMs) {
-		if (predicate()) return;
-		await new Promise((r) => setTimeout(r, 100));
-	}
-	throw new Error(`waitFor timed out after ${timeoutMs}ms`);
-}