@remit/sqs-client 0.0.16 → 0.0.18

package/src/attempt-budget.test.ts

@@ -1,58 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import { attemptBudget } from "./attempt-budget.js";
-
-describe("attemptBudget", () => {
-	afterEach(() => {
-		delete process.env.EXAMPLE_MAX_ATTEMPTS;
-	});
-
-	it("parses the named env var as a base-10 integer", () => {
-		assert.equal(
-			attemptBudget("EXAMPLE_MAX_ATTEMPTS", 3, {
-				EXAMPLE_MAX_ATTEMPTS: "5",
-			}),
-			5,
-		);
-		assert.equal(
-			attemptBudget("EXAMPLE_MAX_ATTEMPTS", 3, {
-				EXAMPLE_MAX_ATTEMPTS: "10",
-			}),
-			10,
-		);
-	});
-
-	it("reads only the named var, so budgets stay independent", () => {
-		assert.equal(
-			attemptBudget("EXAMPLE_MAX_ATTEMPTS", 3, {
-				OTHER_MAX_ATTEMPTS: "9",
-			}),
-			3,
-		);
-	});
-
-	it("falls back when the var is absent or empty", () => {
-		assert.equal(attemptBudget("EXAMPLE_MAX_ATTEMPTS", 3, {}), 3);
-		assert.equal(
-			attemptBudget("EXAMPLE_MAX_ATTEMPTS", 7, { EXAMPLE_MAX_ATTEMPTS: "" }),
-			7,
-		);
-	});
-
-	it("falls back on a value that is not a positive integer", () => {
-		for (const raw of ["nope", "0", "-1", "NaN", " "]) {
-			assert.equal(
-				attemptBudget("EXAMPLE_MAX_ATTEMPTS", 3, {
-					EXAMPLE_MAX_ATTEMPTS: raw,
-				}),
-				3,
-				`expected ${JSON.stringify(raw)} to fall back`,
-			);
-		}
-	});
-
-	it("reads process.env when no environment is supplied", () => {
-		process.env.EXAMPLE_MAX_ATTEMPTS = "4";
-		assert.equal(attemptBudget("EXAMPLE_MAX_ATTEMPTS", 3), 4);
-	});
-});

package/src/heartbeat.test.ts

@@ -1,102 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp, readdir, readFile, stat, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { afterEach, describe, it } from "node:test";
-import { clearHeartbeats, createHeartbeat } from "./heartbeat.js";
-
-const heartbeatPrefix = async (): Promise<string> => {
-	const dir = await mkdtemp(join(tmpdir(), "remit-heartbeat-"));
-	return join(dir, "imap-worker");
-};
-
-describe("createHeartbeat", () => {
-	afterEach(() => {
-		delete process.env.WORKER_HEARTBEAT_PREFIX;
-	});
-
-	it("writes one file per queue and advances its mtime on the next beat", async () => {
-		const prefix = await heartbeatPrefix();
-		const body = createHeartbeat("remit-body", prefix);
-		const flags = createHeartbeat("remit-flags.fifo", prefix);
-
-		await body();
-		await flags();
-		assert.deepEqual((await readdir(dirname(prefix))).sort(), [
-			"imap-worker.remit-body",
-			"imap-worker.remit-flags.fifo",
-		]);
-
-		const contents = await readFile(`${prefix}.remit-body`, "utf8");
-		assert.ok(
-			!Number.isNaN(Date.parse(contents.trim())),
-			`heartbeat contents should be a timestamp, got ${contents}`,
-		);
-
-		// The healthcheck reads mtime and nothing else, so a rewrite that leaves
-		// the file byte-identical would have to advance it anyway.
-		const first = await stat(`${prefix}.remit-body`);
-		await new Promise((resolve) => setTimeout(resolve, 20));
-		await body();
-		const second = await stat(`${prefix}.remit-body`);
-		assert.ok(
-			second.mtimeMs > first.mtimeMs,
-			`the second beat did not advance mtime: ${second.mtimeMs} <= ${first.mtimeMs}`,
-		);
-	});
-
-	it("writes under WORKER_HEARTBEAT_PREFIX when no prefix is given", async () => {
-		const prefix = await heartbeatPrefix();
-		process.env.WORKER_HEARTBEAT_PREFIX = prefix;
-
-		await createHeartbeat("remit-smtp")();
-
-		assert.equal((await stat(`${prefix}.remit-smtp`)).isFile(), true);
-	});
-
-	it("writes nothing when WORKER_HEARTBEAT_PREFIX is unset", async () => {
-		const prefix = await heartbeatPrefix();
-
-		await createHeartbeat("remit-smtp")();
-
-		assert.deepEqual(await readdir(dirname(prefix)), []);
-	});
-
-	it("rejects when the heartbeat directory does not exist", async () => {
-		const heartbeat = createHeartbeat(
-			"remit-smtp",
-			"/nonexistent/remit/worker",
-		);
-
-		await assert.rejects(() => heartbeat(), /ENOENT/);
-	});
-});
-
-describe("clearHeartbeats", () => {
-	afterEach(() => {
-		delete process.env.WORKER_HEARTBEAT_PREFIX;
-	});
-
-	it("removes this service's files and leaves every other service's alone", async () => {
-		const prefix = await heartbeatPrefix();
-		const directory = dirname(prefix);
-		await writeFile(`${prefix}.remit-body`, "stale\n");
-		await writeFile(`${prefix}.remit-retired-queue`, "stale\n");
-		await writeFile(join(directory, "smtp-worker.remit-smtp"), "fresh\n");
-
-		await clearHeartbeats(prefix);
-
-		assert.deepEqual(await readdir(directory), ["smtp-worker.remit-smtp"]);
-	});
-
-	it("does nothing when WORKER_HEARTBEAT_PREFIX is unset", async () => {
-		await clearHeartbeats();
-	});
-
-	it("rejects when the heartbeat directory does not exist", async () => {
-		await assert.rejects(
-			() => clearHeartbeats("/nonexistent/remit/worker"),
-			/ENOENT/,
-		);
-	});
-});

package/src/index.test.ts

@@ -1,39 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-import { resolveSqsCredentials } from "./index.js";
-
-test("returns the SQS pair when both are set", () => {
-	const creds = resolveSqsCredentials({
-		SQS_ACCESS_KEY_ID: "SCWXXX",
-		SQS_SECRET_ACCESS_KEY: "secret",
-	});
-	assert.deepEqual(creds, { accessKeyId: "SCWXXX", secretAccessKey: "secret" });
-});
-
-test("falls back to the default chain when the access key is missing", () => {
-	assert.equal(
-		resolveSqsCredentials({ SQS_SECRET_ACCESS_KEY: "secret" }),
-		undefined,
-	);
-});
-
-test("falls back to the default chain when the secret is missing", () => {
-	assert.equal(
-		resolveSqsCredentials({ SQS_ACCESS_KEY_ID: "SCWXXX" }),
-		undefined,
-	);
-});
-
-test("falls back to the default chain when neither is set", () => {
-	assert.equal(resolveSqsCredentials({}), undefined);
-});
-
-test("ignores the AWS S3 credentials — reads only the SQS pair", () => {
-	assert.equal(
-		resolveSqsCredentials({
-			AWS_ACCESS_KEY_ID: "AKIA",
-			AWS_SECRET_ACCESS_KEY: "aws-secret",
-		}),
-		undefined,
-	);
-});

package/src/poller.test.ts

@@ -1,301 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it, mock } from "node:test";
-import { SQSClient } from "@aws-sdk/client-sqs";
-import type { Context, SQSBatchResponse, SQSEvent } from "aws-lambda";
-import { runQueuePoller } from "./poller.js";
-
-const QUEUE_URL = "http://localhost:9324/000000000000/remit-test";
-
-const buildLog = () => ({
-	info: mock.fn((_fields: Record<string, unknown>, _message: string) => {}),
-	error: mock.fn((_fields: Record<string, unknown>, _message: string) => {}),
-});
-
-const buildMessage = (id: string) => ({
-	MessageId: id,
-	ReceiptHandle: `receipt-${id}`,
-	Body: "{}",
-	Attributes: { ApproximateReceiveCount: "1" },
-});
-
-describe("runQueuePoller", () => {
-	it("deletes succeeded messages and leaves batchItemFailures for redelivery, then stops on signal", async () => {
-		const deletedReceiptHandles: string[] = [];
-		let receiveCalls = 0;
-
-		// SQSClient.prototype.send is mocked globally (poller.ts constructs its
-		// own client internally — there is no injection seam), matching the
-		// same shape every AWS SDK v3 command carries: `{ input, constructor }`.
-		const sendMock = mock.method(
-			SQSClient.prototype,
-			"send",
-			// biome-ignore lint/suspicious/noExplicitAny: minimal SDK command shape, not worth typing per-command here
-			async function (this: SQSClient, command: any) {
-				if (command.constructor.name === "ReceiveMessageCommand") {
-					receiveCalls++;
-					if (receiveCalls === 1) {
-						// Simulate the shutdown signal landing while this batch is
-						// in flight — the loop is expected to finish processing it
-						// (delete succeeded / leave failures) and then exit before
-						// issuing a second ReceiveMessage.
-						process.emit("SIGWINCH", "SIGWINCH");
-						return { Messages: [buildMessage("m1"), buildMessage("m2")] };
-					}
-					throw new Error(
-						"unexpected second ReceiveMessage — poller did not stop on signal",
-					);
-				}
-				if (command.constructor.name === "DeleteMessageCommand") {
-					deletedReceiptHandles.push(command.input.ReceiptHandle);
-					return {};
-				}
-				throw new Error(`unexpected command: ${command.constructor.name}`);
-			},
-		);
-
-		const handler = mock.fn(
-			async (_event: SQSEvent): Promise<SQSBatchResponse> => ({
-				batchItemFailures: [{ itemIdentifier: "m2" }],
-			}),
-		);
-
-		try {
-			await runQueuePoller({
-				targets: [{ queueUrl: QUEUE_URL, handler, functionName: "test-fn" }],
-				log: buildLog(),
-				signals: ["SIGWINCH"],
-			});
-		} finally {
-			sendMock.mock.restore();
-		}
-
-		assert.equal(handler.mock.calls.length, 1);
-		const event = handler.mock.calls[0]?.arguments[0] as SQSEvent;
-		assert.deepEqual(
-			event.Records.map((r) => r.messageId),
-			["m1", "m2"],
-		);
-
-		// m1 succeeded (not in batchItemFailures) -> deleted. m2 failed -> left
-		// for redelivery, matching the SQS batchItemFailures contract.
-		assert.deepEqual(deletedReceiptHandles, ["receipt-m1"]);
-	});
-
-	it("aborts an in-flight idle long-poll on signal instead of waiting it out", async () => {
-		let receiveCalls = 0;
-		let sawAbortSignal = false;
-
-		const sendMock = mock.method(
-			SQSClient.prototype,
-			"send",
-			// biome-ignore lint/suspicious/noExplicitAny: minimal SDK command shape
-			async function (this: SQSClient, command: any, options?: any) {
-				if (command.constructor.name === "ReceiveMessageCommand") {
-					receiveCalls++;
-					if (receiveCalls > 1) {
-						throw new Error(
-							"a second ReceiveMessage was issued — the abort did not end the poll",
-						);
-					}
-					const signal: AbortSignal | undefined = options?.abortSignal;
-					sawAbortSignal = signal instanceof AbortSignal;
-					// Model an empty long poll that only ever ends because it is
-					// aborted: request shutdown, then resolve solely on abort. A
-					// poller that waited out WaitTimeSeconds would hang this test.
-					process.emit("SIGWINCH", "SIGWINCH");
-					return await new Promise((_resolve, reject) => {
-						const fail = () =>
-							reject(
-								Object.assign(new Error("aborted"), { name: "AbortError" }),
-							);
-						if (signal?.aborted) return fail();
-						signal?.addEventListener("abort", fail, { once: true });
-					});
-				}
-				throw new Error(`unexpected command: ${command.constructor.name}`);
-			},
-		);
-
-		try {
-			await runQueuePoller({
-				targets: [
-					{ queueUrl: QUEUE_URL, handler: mock.fn(), functionName: "test-fn" },
-				],
-				log: buildLog(),
-				signals: ["SIGWINCH"],
-				// A no-op heartbeat keeps this case about the abort alone, off the
-				// real heartbeat file the default writer would touch.
-				createHeartbeat: () => async () => {},
-			});
-		} finally {
-			sendMock.mock.restore();
-		}
-
-		assert.ok(sawAbortSignal, "the receive was issued without an abort signal");
-		assert.equal(receiveCalls, 1);
-	});
-
-	it("gives every target its own heartbeat, beaten at the top of each receive attempt", async () => {
-		const beatsByQueue = new Map<string, number>();
-		let receiveCalls = 0;
-
-		const sendMock = mock.method(
-			SQSClient.prototype,
-			"send",
-			// biome-ignore lint/suspicious/noExplicitAny: minimal SDK command shape, not worth typing per-command here
-			async function (this: SQSClient, command: any) {
-				if (command.constructor.name !== "ReceiveMessageCommand") {
-					throw new Error(`unexpected command: ${command.constructor.name}`);
-				}
-				// Two empty receives per target, then shut down: the heartbeat has
-				// to be written before the receive, and on an empty poll too — an
-				// idle queue is the normal state of a healthy worker.
-				receiveCalls++;
-				if (receiveCalls >= 4) process.emit("SIGWINCH", "SIGWINCH");
-				return { Messages: [] };
-			},
-		);
-
-		try {
-			await runQueuePoller({
-				targets: [
-					{ queueUrl: QUEUE_URL, handler: async () => {}, functionName: "a" },
-					{
-						queueUrl: `${QUEUE_URL}-2`,
-						handler: async () => {},
-						functionName: "b",
-					},
-				],
-				log: buildLog(),
-				signals: ["SIGWINCH"],
-				createHeartbeat: (name) => async () => {
-					beatsByQueue.set(name, (beatsByQueue.get(name) ?? 0) + 1);
-				},
-			});
-		} finally {
-			sendMock.mock.restore();
-		}
-
-		assert.ok(receiveCalls >= 4, `only ${receiveCalls} receives ran`);
-		// One heartbeat per queue, named after it: a wedged loop has to go stale
-		// on its own rather than ride on a sibling that is still turning.
-		assert.deepEqual([...beatsByQueue.keys()].sort(), [
-			"remit-test",
-			"remit-test-2",
-		]);
-		assert.equal(
-			[...beatsByQueue.values()].reduce((sum, count) => sum + count, 0),
-			receiveCalls,
-		);
-	});
-
-	it("keeps polling and logs when a heartbeat write fails", async () => {
-		let receiveCalls = 0;
-		const log = buildLog();
-
-		const sendMock = mock.method(
-			SQSClient.prototype,
-			"send",
-			// biome-ignore lint/suspicious/noExplicitAny: minimal SDK command shape, not worth typing per-command here
-			async function (this: SQSClient, command: any) {
-				if (command.constructor.name !== "ReceiveMessageCommand") {
-					throw new Error(`unexpected command: ${command.constructor.name}`);
-				}
-				receiveCalls++;
-				if (receiveCalls >= 2) process.emit("SIGWINCH", "SIGWINCH");
-				return { Messages: [] };
-			},
-		);
-
-		try {
-			// A full disk is the likeliest cause, and the moment the loop must stay
-			// up: the healthcheck reports the missed beat by itself.
-			await runQueuePoller({
-				targets: [
-					{ queueUrl: QUEUE_URL, handler: async () => {}, functionName: "a" },
-				],
-				log,
-				signals: ["SIGWINCH"],
-				createHeartbeat: () => () =>
-					Promise.reject(new Error("ENOSPC: no space left on device")),
-			});
-		} finally {
-			sendMock.mock.restore();
-		}
-
-		assert.ok(receiveCalls >= 2, `only ${receiveCalls} receives ran`);
-		const failures = log.error.mock.calls.filter(
-			(call) => call.arguments[1] === "poller: heartbeat write failed",
-		);
-		assert.equal(failures.length, receiveCalls);
-		assert.match(String(failures[0]?.arguments[0]?.error), /ENOSPC/);
-	});
-
-	// The `requestId` every line of one invocation is grouped by
-	// (deploy/vps/README.md, "Logs") is minted here, and it has to reach both the
-	// handler and the poller's own bracketing lines — otherwise grouping on it
-	// stops right before the line saying what happened to the message.
-	it("gives each batch its own requestId, on the handler context and on its own lines", async () => {
-		let receiveCalls = 0;
-		const sendMock = mock.method(
-			SQSClient.prototype,
-			"send",
-			// biome-ignore lint/suspicious/noExplicitAny: minimal SDK command shape, not worth typing per-command here
-			async function (this: SQSClient, command: any) {
-				if (command.constructor.name === "ReceiveMessageCommand") {
-					receiveCalls++;
-					if (receiveCalls >= 2) process.emit("SIGWINCH", "SIGWINCH");
-					return { Messages: [buildMessage(`m${receiveCalls}`)] };
-				}
-				if (command.constructor.name === "DeleteMessageCommand") return {};
-				throw new Error(`unexpected command: ${command.constructor.name}`);
-			},
-		);
-
-		const handler = mock.fn(
-			async (
-				_event: SQSEvent,
-				_context: Context,
-			): Promise<SQSBatchResponse> => ({ batchItemFailures: [] }),
-		);
-		const log = buildLog();
-
-		try {
-			await runQueuePoller({
-				targets: [{ queueUrl: QUEUE_URL, handler, functionName: "test-fn" }],
-				log,
-				signals: ["SIGWINCH"],
-				createHeartbeat: () => async () => {},
-			});
-		} finally {
-			sendMock.mock.restore();
-		}
-
-		const requestIds = handler.mock.calls.map(
-			(call) => call.arguments[1].awsRequestId,
-		);
-		assert.equal(requestIds.length, 2);
-		for (const requestId of requestIds)
-			assert.match(requestId, /^[0-9a-f-]{36}$/);
-		assert.notEqual(requestIds[0], requestIds[1]);
-
-		const bracketing = ["poller: invoking handler", "poller: batch processed"];
-		for (const message of bracketing) {
-			const lines = log.info.mock.calls.filter(
-				(call) => call.arguments[1] === message,
-			);
-			assert.equal(lines.length, 2, `expected two ${message} lines`);
-			assert.deepEqual(
-				lines.map((call) => call.arguments[0].requestId),
-				requestIds,
-			);
-		}
-	});
-
-	it("throws when constructed with no targets", async () => {
-		await assert.rejects(
-			() => runQueuePoller({ targets: [], log: buildLog() }),
-			/no targets configured/,
-		);
-	});
-});