semola 0.5.0 → 0.5.2

package/dist/lib/queue/index.test.js

@@ -1,740 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { Queue } from "./index.js";
-class MockRedisClient {
-    lists = new Map();
-    shouldFail = false;
-    setShouldFail(value) {
-        this.shouldFail = value;
-    }
-    async lpush(key, value) {
-        if (this.shouldFail) {
-            throw new Error("Redis connection error");
-        }
-        if (!this.lists.has(key)) {
-            this.lists.set(key, []);
-        }
-        this.lists.get(key)?.unshift(value);
-        return this.lists.get(key)?.length ?? 0;
-    }
-    async rpop(key) {
-        if (this.shouldFail) {
-            throw new Error("Redis connection error");
-        }
-        const list = this.lists.get(key);
-        if (!list || list.length === 0) {
-            return null;
-        }
-        return list.pop();
-    }
-    clear() {
-        this.lists.clear();
-    }
-    getList(key) {
-        return this.lists.get(key) ?? [];
-    }
-}
-const createMockRedis = () => {
-    return new MockRedisClient();
-};
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-describe("Queue", () => {
-    describe("enqueue", () => {
-        test.concurrent("should enqueue a job successfully", async () => {
-            const redis = createMockRedis();
-            const handler = () => { };
-            const queue = new Queue({ name: "test", redis, retries: 3, handler });
-            const [error, jobId] = await queue.enqueue({ message: "hello" });
-            expect(error).toBeNull();
-            expect(jobId).toBeDefined();
-            expect(typeof jobId).toBe("string");
-            await queue.stop();
-        });
-        test.concurrent("should handle Redis connection errors", async () => {
-            const redis = createMockRedis();
-            const handler = () => { };
-            const queue = new Queue({ name: "test", redis, retries: 3, handler });
-            redis.setShouldFail(true);
-            const [error, jobId] = await queue.enqueue({ message: "hello" });
-            expect(error).toEqual({
-                type: "QueueError",
-                message: "Unable to enqueue job",
-            });
-            expect(jobId).toBeNull();
-            await queue.stop();
-        });
-        test.concurrent("should handle serialization errors", async () => {
-            const redis = createMockRedis();
-            const handler = () => { };
-            const queue = new Queue({ name: "test", redis, retries: 3, handler });
-            const circular = { a: 1 };
-            circular.self = circular;
-            const [error, jobId] = await queue.enqueue(circular);
-            expect(error).toEqual({
-                type: "QueueError",
-                message: "Unable to serialize job data",
-            });
-            expect(jobId).toBeNull();
-            await queue.stop();
-        });
-    });
-    describe("processing", () => {
-        test.concurrent("should verify job is re-enqueued on failure", async () => {
-            const redis = createMockRedis();
-            let callCount = 0;
-            const handler = () => {
-                callCount++;
-                if (callCount === 1) {
-                    throw new Error("First attempt fails");
-                }
-            };
-            const queue = new Queue({ name: "test", redis, retries: 3, handler });
-            await queue.enqueue({ message: "test" });
-            await sleep(2500);
-            expect(callCount).toBeGreaterThan(1);
-            await queue.stop();
-        });
-        test.concurrent("should process jobs in FIFO order", async () => {
-            const redis = createMockRedis();
-            const processed = [];
-            const handler = (data) => {
-                processed.push(data.message);
-            };
-            const queue = new Queue({ name: "test", redis, retries: 3, handler });
-            await queue.enqueue({ message: "first" });
-            await queue.enqueue({ message: "second" });
-            await queue.enqueue({ message: "third" });
-            await sleep(500);
-            expect(processed).toEqual(["first", "second", "third"]);
-            await queue.stop();
-        });
-        test.concurrent("should call onSuccess callback on successful processing", async () => {
-            const redis = createMockRedis();
-            const handler = () => { };
-            const successJobs = [];
-            const onSuccess = (job) => {
-                successJobs.push(job.id);
-            };
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 3,
-                handler,
-                onSuccess,
-            });
-            const [, jobId] = await queue.enqueue({ message: "hello" });
-            await sleep(200);
-            expect(jobId).not.toBeNull();
-            if (jobId) {
-                expect(successJobs).toContain(jobId);
-            }
-            await queue.stop();
-        });
-        test.concurrent("should call onRetry callback when job fails but will be retried", async () => {
-            const redis = createMockRedis();
-            let attempts = 0;
-            const handler = () => {
-                attempts++;
-                if (attempts < 2) {
-                    throw new Error("First attempt fails");
-                }
-            };
-            const retryContexts = [];
-            const onRetry = (context) => {
-                retryContexts.push({
-                    id: context.job.id,
-                    attempts: context.job.attempts,
-                    error: context.error,
-                    nextRetryDelayMs: context.nextRetryDelayMs,
-                    retriesRemaining: context.retriesRemaining,
-                });
-            };
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 2,
-                handler,
-                onRetry,
-            });
-            const [, jobId] = await queue.enqueue({ message: "hello" });
-            await sleep(2500);
-            expect(jobId).not.toBeNull();
-            expect(retryContexts.length).toBe(1);
-            if (jobId) {
-                expect(retryContexts[0]?.id).toBe(jobId);
-                expect(retryContexts[0]?.error).toBe("First attempt fails");
-                expect(retryContexts[0]?.attempts).toBe(1);
-                expect(retryContexts[0]?.nextRetryDelayMs).toBe(1000);
-                expect(retryContexts[0]?.retriesRemaining).toBe(1);
-            }
-            await queue.stop();
-        });
-        test.concurrent("should call onRetry multiple times for multiple failures", async () => {
-            const redis = createMockRedis();
-            let attempts = 0;
-            const handler = () => {
-                attempts++;
-                throw new Error(`Attempt ${attempts} failed`);
-            };
-            const retryContexts = [];
-            const onRetry = (context) => {
-                retryContexts.push({
-                    attempts: context.job.attempts,
-                    error: context.error,
-                    nextRetryDelayMs: context.nextRetryDelayMs,
-                });
-            };
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 2,
-                handler,
-                onRetry,
-            });
-            await queue.enqueue({ message: "hello" });
-            await sleep(4000);
-            // Should have called onRetry 2 times (attempts 1, 2)
-            expect(retryContexts.length).toBe(2);
-            expect(retryContexts[0]?.attempts).toBe(1);
-            expect(retryContexts[0]?.nextRetryDelayMs).toBe(1000);
-            expect(retryContexts[1]?.attempts).toBe(2);
-            expect(retryContexts[1]?.nextRetryDelayMs).toBe(2000);
-            await queue.stop();
-        });
-        test.concurrent("should not call onRetry when job succeeds on first try", async () => {
-            const redis = createMockRedis();
-            const handler = () => { };
-            const retryJobs = [];
-            const onRetry = (context) => {
-                retryJobs.push(context.job.id);
-            };
-            const successJobs = [];
-            const onSuccess = (job) => {
-                successJobs.push(job.id);
-            };
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 3,
-                handler,
-                onRetry,
-                onSuccess,
-            });
-            const [, jobId] = await queue.enqueue({ message: "hello" });
-            await sleep(200);
-            expect(jobId).not.toBeNull();
-            expect(retryJobs.length).toBe(0);
-            if (jobId) {
-                expect(successJobs).toContain(jobId);
-            }
-            await queue.stop();
-        });
-        test.concurrent("should call onRetry then onError when retries exhausted", async () => {
-            const redis = createMockRedis();
-            const handler = () => {
-                throw new Error("Always fails");
-            };
-            const retryJobs = [];
-            const errorJobs = [];
-            const onRetry = (context) => {
-                retryJobs.push(context.job.id);
-            };
-            const onError = (context) => {
-                errorJobs.push(context.job.id);
-            };
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 2,
-                handler,
-                onRetry,
-                onError,
-            });
-            const [, jobId] = await queue.enqueue({ message: "hello" });
-            await sleep(4000);
-            expect(jobId).not.toBeNull();
-            expect(retryJobs.length).toBe(2);
-            expect(errorJobs.length).toBe(1);
-            if (jobId) {
-                expect(retryJobs).toContain(jobId);
-                expect(errorJobs).toContain(jobId);
-            }
-            await queue.stop();
-        });
-        test.concurrent("should retry failed jobs with exponential backoff", async () => {
-            const redis = createMockRedis();
-            let attempts = 0;
-            const handler = () => {
-                attempts++;
-                if (attempts < 2) {
-                    throw new Error("Processing failed");
-                }
-            };
-            const queue = new Queue({ name: "test", redis, retries: 2, handler });
-            await queue.enqueue({ message: "hello" });
-            await sleep(3000);
-            expect(attempts).toBe(2);
-            await queue.stop();
-        });
-        test.concurrent("should respect maxRetries limit", async () => {
-            const redis = createMockRedis();
-            let attempts = 0;
-            const handler = () => {
-                attempts++;
-                throw new Error("Always fails");
-            };
-            const errorJobs = [];
-            const onError = (context) => {
-                errorJobs.push(context.job.id);
-            };
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 2,
-                handler,
-                onError,
-            });
-            const [, jobId] = await queue.enqueue({ message: "hello" });
-            await sleep(4000);
-            expect(attempts).toBe(3);
-            expect(jobId).not.toBeNull();
-            if (jobId) {
-                expect(errorJobs).toContain(jobId);
-            }
-            await queue.stop();
-        });
-        test.concurrent("should call onError when retries are exhausted", async () => {
-            const redis = createMockRedis();
-            const handler = () => {
-                throw new Error("Processing failed");
-            };
-            const errorContexts = [];
-            const onError = (context) => {
-                errorContexts.push({
-                    id: context.job.id,
-                    lastError: context.lastError,
-                    totalDurationMs: context.totalDurationMs,
-                    totalAttempts: context.totalAttempts,
-                    errorHistory: context.errorHistory,
-                });
-            };
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 1,
-                handler,
-                onError,
-            });
-            const [, jobId] = await queue.enqueue({ message: "hello" });
-            await sleep(3000);
-            expect(errorContexts.length).toBe(1);
-            expect(jobId).not.toBeNull();
-            if (jobId) {
-                expect(errorContexts[0]?.id).toBe(jobId);
-                expect(errorContexts[0]?.lastError).toBe("Processing failed");
-                expect(errorContexts[0]?.totalAttempts).toBe(2);
-                expect(errorContexts[0]?.totalDurationMs).toBeGreaterThan(0);
-                expect(errorContexts[0]?.errorHistory).toBeDefined();
-                expect(errorContexts[0]?.errorHistory.length).toBeGreaterThan(0);
-            }
-            await queue.stop();
-        });
-        test.concurrent("should handle handler errors", async () => {
-            const redis = createMockRedis();
-            const handler = () => {
-                throw new Error("Handler error");
-            };
-            const errorJobs = [];
-            const onError = (context) => {
-                errorJobs.push(context.job.id);
-            };
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 1,
-                handler,
-                onError,
-            });
-            const [, jobId] = await queue.enqueue({ message: "hello" });
-            await sleep(3000);
-            expect(jobId).not.toBeNull();
-            if (jobId) {
-                expect(errorJobs).toContain(jobId);
-            }
-            await queue.stop();
-        });
-    });
-    describe("lifecycle", () => {
-        test.concurrent("should auto-start processing in constructor", async () => {
-            const redis = createMockRedis();
-            const processed = [];
-            const handler = (data) => {
-                processed.push(data.message);
-            };
-            const queue = new Queue({ name: "test", redis, retries: 3, handler });
-            await queue.enqueue({ message: "hello" });
-            await sleep(200);
-            expect(processed).toContain("hello");
-            await queue.stop();
-        });
-        test.concurrent("should stop processing after stop() is called", async () => {
-            const redis = createMockRedis();
-            const processed = [];
-            const handler = (data) => {
-                processed.push(data.message);
-            };
-            const queue = new Queue({ name: "test", redis, retries: 3, handler });
-            await queue.enqueue({ message: "first" });
-            await sleep(200);
-            await queue.stop();
-            await queue.enqueue({ message: "second" });
-            await sleep(200);
-            expect(processed).toContain("first");
-            expect(processed).not.toContain("second");
-        });
-    });
-    describe("edge cases", () => {
-        test.concurrent("should handle empty queue gracefully", async () => {
-            const redis = createMockRedis();
-            const handler = () => { };
-            const queue = new Queue({ name: "test", redis, retries: 3, handler });
-            await sleep(200);
-            await queue.stop();
-        });
-        test.concurrent("should handle async handlers", async () => {
-            const redis = createMockRedis();
-            const processed = [];
-            const handler = async (data) => {
-                await sleep(10);
-                processed.push(data.message);
-            };
-            const queue = new Queue({ name: "test", redis, retries: 3, handler });
-            await queue.enqueue({ message: "async" });
-            await sleep(200);
-            expect(processed).toContain("async");
-            await queue.stop();
-        });
-        test.concurrent("should handle multiple queues with different names", async () => {
-            const redis = createMockRedis();
-            const processed1 = [];
-            const processed2 = [];
-            const handler1 = (data) => {
-                processed1.push(data.message);
-            };
-            const handler2 = (data) => {
-                processed2.push(data.message);
-            };
-            const queue1 = new Queue({
-                name: "queue1",
-                redis,
-                retries: 3,
-                handler: handler1,
-            });
-            const queue2 = new Queue({
-                name: "queue2",
-                redis,
-                retries: 3,
-                handler: handler2,
-            });
-            await queue1.enqueue({ message: "q1" });
-            await queue2.enqueue({ message: "q2" });
-            await sleep(200);
-            expect(processed1).toContain("q1");
-            expect(processed1).not.toContain("q2");
-            expect(processed2).toContain("q2");
-            expect(processed2).not.toContain("q1");
-            await queue1.stop();
-            await queue2.stop();
-        });
-        test.concurrent("should handle deserialization errors gracefully", async () => {
-            const redis = createMockRedis();
-            const handler = () => { };
-            const queue = new Queue({ name: "test", redis, retries: 3, handler });
-            await redis.lpush("queue:test:jobs", "invalid json {");
-            await sleep(200);
-            await queue.stop();
-        });
-        test.concurrent("should move malformed job to dead-letter queue on parse error", async () => {
-            const redis = createMockRedis();
-            const parseErrors = [];
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 3,
-                handler: () => {
-                    throw new Error("Handler should not be called");
-                },
-                onParseError: async (context) => {
-                    parseErrors.push(context);
-                },
-                pollInterval: 10,
-            });
-            const malformedData = '{"id":"test","incomplete';
-            await redis.lpush("queue:test:jobs", malformedData);
-            await sleep(100);
-            await queue.stop();
-            const deadLetterQueue = redis.getList("queue:test:dead-letter");
-            expect(deadLetterQueue.length).toBe(1);
-            const firstEntry = deadLetterQueue[0];
-            expect(firstEntry).toBeDefined();
-            if (firstEntry) {
-                const deadLetterEntry = JSON.parse(firstEntry);
-                expect(deadLetterEntry.jobData).toBe(malformedData);
-                expect(deadLetterEntry.parseError).toBeDefined();
-                expect(deadLetterEntry.timestamp).toBeGreaterThan(0);
-            }
-            expect(parseErrors.length).toBe(1);
-            const firstError = parseErrors[0];
-            expect(firstError).toBeDefined();
-            if (firstError) {
-                expect(firstError.rawJobData).toBe(malformedData);
-                expect(firstError.parseError).toBeDefined();
-                expect(firstError.timestamp).toBeGreaterThan(0);
-            }
-        });
-        test.concurrent("should preserve multiple malformed jobs in dead-letter queue", async () => {
-            const redis = createMockRedis();
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 3,
-                handler: () => { },
-                pollInterval: 10,
-            });
-            const malformedPayloads = [
-                "invalid json",
-                '{"incomplete": "object"',
-                '["unclosed", "array"',
-            ];
-            for (const payload of malformedPayloads) {
-                await redis.lpush("queue:test:jobs", payload);
-            }
-            await sleep(150);
-            await queue.stop();
-            const deadLetterQueue = redis.getList("queue:test:dead-letter");
-            expect(deadLetterQueue.length).toBe(malformedPayloads.length);
-            deadLetterQueue.forEach((entry) => {
-                const parsed = JSON.parse(entry);
-                expect(parsed.jobData).toBeDefined();
-                expect(parsed.parseError).toBeDefined();
-                expect(parsed.timestamp).toBeGreaterThan(0);
-            });
-        });
-        test.concurrent("should call onParseError with parse error details and raw jobData", async () => {
-            const redis = createMockRedis();
-            const parseErrors = [];
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 3,
-                handler: () => { },
-                onParseError: async (context) => {
-                    parseErrors.push(context);
-                },
-                pollInterval: 10,
-            });
-            const malformedData = '{"bad": json}';
-            await redis.lpush("queue:test:jobs", malformedData);
-            await sleep(100);
-            await queue.stop();
-            expect(parseErrors.length).toBe(1);
-            const firstError = parseErrors[0];
-            expect(firstError).toBeDefined();
-            if (firstError) {
-                expect(firstError.rawJobData).toBe(malformedData);
-                expect(firstError.parseError).toBeDefined();
-                expect(firstError.timestamp).toBeGreaterThan(0);
-            }
-        });
-        test.concurrent("should continue processing valid jobs after malformed jobs", async () => {
-            const redis = createMockRedis();
-            const processed = [];
-            const parseErrors = [];
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 3,
-                handler: async (data) => {
-                    processed.push(data);
-                },
-                onParseError: async (context) => {
-                    parseErrors.push(context);
-                },
-                pollInterval: 10,
-            });
-            await redis.lpush("queue:test:jobs", '{"bad": json}');
-            await queue.enqueue({ message: "valid-1" });
-            await redis.lpush("queue:test:jobs", "invalid json");
-            await queue.enqueue({ message: "valid-2" });
-            await sleep(200);
-            await queue.stop();
-            expect(processed.length).toBe(2);
-            expect(processed.some((p) => p.message === "valid-1")).toBe(true);
-            expect(processed.some((p) => p.message === "valid-2")).toBe(true);
-            expect(parseErrors.length).toBe(2);
-            const deadLetterQueue = redis.getList("queue:test:dead-letter");
-            expect(deadLetterQueue.length).toBe(2);
-        });
-        test.concurrent("should handle parse errors even without onError callback", async () => {
-            const redis = createMockRedis();
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 3,
-                handler: () => { },
-                pollInterval: 10,
-            });
-            const malformedData = '{"invalid": json}';
-            await redis.lpush("queue:test:jobs", malformedData);
-            await sleep(100);
-            await queue.stop();
-            const deadLetterQueue = redis.getList("queue:test:dead-letter");
-            expect(deadLetterQueue.length).toBe(1);
-            const firstEntry = deadLetterQueue[0];
-            expect(firstEntry).toBeDefined();
-            if (firstEntry) {
-                const deadLetterEntry = JSON.parse(firstEntry);
-                expect(deadLetterEntry.jobData).toBe(malformedData);
-            }
-        });
-        test.concurrent("should handle completely invalid JSON syntax", async () => {
-            const redis = createMockRedis();
-            const parseErrors = [];
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 3,
-                handler: () => { },
-                onParseError: async (context) => {
-                    parseErrors.push(context);
-                },
-                pollInterval: 10,
-            });
-            const invalidJson = "not valid json at all";
-            await redis.lpush("queue:test:jobs", invalidJson);
-            await sleep(100);
-            await queue.stop();
-            const deadLetterQueue = redis.getList("queue:test:dead-letter");
-            expect(deadLetterQueue.length).toBe(1);
-            const firstEntry = deadLetterQueue[0];
-            expect(firstEntry).toBeDefined();
-            if (firstEntry) {
-                const deadLetterEntry = JSON.parse(firstEntry);
-                expect(deadLetterEntry.jobData).toBe(invalidJson);
-            }
-            expect(parseErrors.length).toBe(1);
-            const firstParseError = parseErrors[0];
-            expect(firstParseError).toBeDefined();
-            if (firstParseError) {
-                expect(firstParseError.rawJobData).toBe(invalidJson);
-                expect(firstParseError.parseError).toBeDefined();
-                expect(firstParseError.timestamp).toBeGreaterThan(0);
-            }
-        });
-        test.concurrent("should handle large job data", async () => {
-            const redis = createMockRedis();
-            const processed = [];
-            const handler = (data) => {
-                processed.push(data);
-            };
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 3,
-                handler,
-            });
-            const largeData = {
-                items: Array.from({ length: 1000 }, (_, i) => ({
-                    id: i,
-                    name: `Item ${i}`,
-                })),
-            };
-            await queue.enqueue(largeData);
-            await sleep(200);
-            expect(processed[0]).toEqual(largeData);
-            await queue.stop();
-        });
-        test.concurrent("should handle job timeout", async () => {
-            const redis = createMockRedis();
-            let attempts = 0;
-            const signalStates = [];
-            const handler = async (_data, signal) => {
-                attempts++;
-                // Capture initial signal state
-                signalStates.push(signal?.aborted ?? false);
-                // Sleep longer than timeout
-                await sleep(500);
-                // Capture signal state after timeout should have fired
-                signalStates.push(signal?.aborted ?? false);
-            };
-            const errorJobs = [];
-            const onError = (context) => {
-                errorJobs.push(context.job.id);
-            };
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 1,
-                handler,
-                timeout: 100,
-                onError,
-            });
-            const [, jobId] = await queue.enqueue({ message: "hello" });
-            await sleep(3000);
-            // Should have retried once due to timeout
-            expect(attempts).toBeGreaterThanOrEqual(2);
-            expect(jobId).not.toBeNull();
-            if (jobId) {
-                expect(errorJobs).toContain(jobId);
-            }
-            // Verify signal was received and got aborted after timeout
-            expect(signalStates.length).toBeGreaterThan(0);
-            expect(signalStates[0]).toBe(false); // Signal not aborted initially
-            // At least one signal should be aborted after timeout fires
-            expect(signalStates.some((state) => state === true)).toBe(true);
-            await queue.stop();
-        });
-        test.concurrent("should respect concurrency limits", async () => {
-            const redis = createMockRedis();
-            let maxConcurrent = 0;
-            let currentConcurrent = 0;
-            const handler = async () => {
-                currentConcurrent++;
-                maxConcurrent = Math.max(maxConcurrent, currentConcurrent);
-                await sleep(50);
-                currentConcurrent--;
-            };
-            const queue = new Queue({
-                name: "test",
-                redis,
-                retries: 1,
-                handler,
-                concurrency: 2,
-            });
-            // Enqueue multiple jobs
-            await queue.enqueue({ message: "1" });
-            await queue.enqueue({ message: "2" });
-            await queue.enqueue({ message: "3" });
-            await queue.enqueue({ message: "4" });
-            await sleep(500);
-            // Should not exceed concurrency limit
-            expect(maxConcurrent).toBeLessThanOrEqual(2);
-            await queue.stop();
-        });
-        test.concurrent("should handle graceful shutdown with pending jobs", async () => {
-            const redis = createMockRedis();
-            const processed = [];
-            const handler = async (data) => {
-                await sleep(50);
-                processed.push(data.message);
-            };
-            const queue = new Queue({ name: "test", redis, retries: 1, handler });
-            await queue.enqueue({ message: "job1" });
-            await queue.enqueue({ message: "job2" });
-            await sleep(100); // Give it time to start processing
-            await queue.stop(); // Should wait for in-flight jobs
-            // Should have completed at least job1
-            expect(processed.length).toBeGreaterThan(0);
-        });
-    });
-});
-//# sourceMappingURL=index.test.js.map