@taicode/common-server 1.0.11 → 1.0.13

package/output/redis-queue/redis-queue.test.js

@@ -1,234 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { catchIt } from '@taicode/common-base';
-import { RedisQueue } from './redis-queue';
-const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
-describe('RedisQueue', () => {
-    const queues = [];
-    afterEach(async () => {
-        for (const queue of queues) {
-            try {
-                await queue.clear();
-            }
-            catch (error) {
-                // 忽略清理错误
-            }
-            queue.disconnect();
-        }
-        queues.length = 0;
-    });
-    const createQueue = (handler, options) => {
-        const uniqueKey = `test:queue:${Date.now()}:${Math.random()}`;
-        const queue = new RedisQueue({
-            redisUrl: REDIS_URL,
-            queueKey: uniqueKey,
-            consumerInterval: 100,
-            maxRetries: 2,
-            ...options,
-            handler,
-        });
-        queues.push(queue);
-        return queue;
-    };
-    describe('连接管理', () => {
-        it('应该成功连接到 Redis', async () => {
-            const queue = createQueue(async () => catchIt(() => { }));
-            await queue.connect();
-            const health = await queue.health();
-            expect(health).toBe(true);
-        });
-        it('连接后应该自动启动消费者', async () => {
-            let processed = false;
-            const queue = createQueue(async () => {
-                processed = true;
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue({ test: true });
-            await new Promise(resolve => setTimeout(resolve, 300));
-            expect(processed).toBe(true);
-        });
-    });
-    describe('任务入队', () => {
-        it('应该成功将任务推入队列', async () => {
-            const queue = createQueue(async () => catchIt(() => { }));
-            await queue.connect();
-            const taskId = await queue.enqueue({ foo: 'bar' });
-            expect(taskId).toBeTruthy();
-            const stats = await queue.statistics();
-            expect(stats.pending).toBeGreaterThan(0);
-        });
-        it('应该能够批量入队任务', async () => {
-            const queue = createQueue(async () => catchIt(() => { }));
-            await queue.connect();
-            const taskIds = await queue.enqueue([
-                { value: 1 },
-                { value: 2 },
-                { value: 3 },
-            ]);
-            expect(taskIds).toHaveLength(3);
-            const stats = await queue.statistics();
-            expect(stats.pending + stats.processing).toBe(3);
-        });
-        it('入队的任务应该包含正确的元数据', async () => {
-            const queue = createQueue(async () => catchIt(() => { }));
-            await queue.connect();
-            const taskId = await queue.enqueue({ test: 'data', number: 42 });
-            const task = await queue.getTask(taskId);
-            expect(task).toBeTruthy();
-            expect(task?.id).toBe(taskId);
-            expect(task?.data).toEqual({ test: 'data', number: 42 });
-            expect(task?.status).toBe('pending');
-            expect(task?.retryCount).toBe(0);
-            expect(task?.maxRetries).toBe(2);
-        });
-    });
-    describe('任务处理', () => {
-        it('应该成功处理任务', async () => {
-            const processedData = [];
-            const queue = createQueue(async (data) => {
-                processedData.push(data);
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue({ value: 'test' });
-            await new Promise(resolve => setTimeout(resolve, 500));
-            expect(processedData).toHaveLength(1);
-            expect(processedData[0]).toEqual({ value: 'test' });
-        });
-        it('应该按 FIFO 顺序处理任务', async () => {
-            const processOrder = [];
-            const queue = createQueue(async (data) => {
-                processOrder.push(data.order);
-                await new Promise(resolve => setTimeout(resolve, 50));
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue({ order: 1 });
-            await new Promise(resolve => setTimeout(resolve, 10));
-            await queue.enqueue({ order: 2 });
-            await new Promise(resolve => setTimeout(resolve, 10));
-            await queue.enqueue({ order: 3 });
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            expect(processOrder).toEqual([1, 2, 3]);
-        });
-    });
-    describe('错误处理和重试', () => {
-        it('失败的任务应该自动重试', async () => {
-            let attemptCount = 0;
-            const queue = createQueue(async () => {
-                attemptCount++;
-                if (attemptCount < 2) {
-                    throw new Error('Simulated failure');
-                }
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue({ test: 'retry' });
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            expect(attemptCount).toBe(2);
-        });
-        it('超过最大重试次数应该标记为失败', async () => {
-            let attemptCount = 0;
-            const queue = createQueue(async () => {
-                attemptCount++;
-                throw new Error('Always fails');
-            });
-            await queue.connect();
-            const taskId = await queue.enqueue({ test: 'fail' });
-            await new Promise(resolve => setTimeout(resolve, 1500));
-            expect(attemptCount).toBe(3); // 初始 + 2 次重试
-            const task = await queue.getTask(taskId);
-            expect(task?.status).toBe('failed');
-        });
-    });
-    describe('消费者管理', () => {
-        it('断开连接后消费者应该停止', async () => {
-            let processCount = 0;
-            const queue = createQueue(async () => {
-                processCount++;
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue({ test: 1 });
-            await new Promise(resolve => setTimeout(resolve, 300));
-            expect(processCount).toBe(1);
-            queue.disconnect();
-            await queue.connect();
-            await queue.enqueue({ test: 2 });
-            await new Promise(resolve => setTimeout(resolve, 300));
-            expect(processCount).toBe(2);
-        });
-    });
-    describe('队列操作', () => {
-        it('应该正确返回队列统计信息', async () => {
-            const queue = createQueue(async () => {
-                await new Promise(resolve => setTimeout(resolve, 100));
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue([{ data: 1 }, { data: 2 }, { data: 3 }]);
-            await new Promise(resolve => setTimeout(resolve, 50));
-            const stats = await queue.statistics();
-            expect(stats.pending + stats.processing).toBeGreaterThan(0);
-        });
-        it('应该能够清空队列', async () => {
-            const queue = createQueue(async () => catchIt(() => { }));
-            await queue.connect();
-            await queue.enqueue([{ data: 1 }, { data: 2 }]);
-            await queue.clear();
-            const stats = await queue.statistics();
-            expect(stats.pending).toBe(0);
-        });
-    });
-    describe('并发处理', () => {
-        it('应该支持并发处理多个任务', async () => {
-            const processing = [];
-            const completed = [];
-            const queue = createQueue(async (data) => {
-                processing.push(data.taskId);
-                await new Promise(resolve => setTimeout(resolve, 200));
-                completed.push(data.taskId);
-                return catchIt(() => { });
-            }, { concurrency: 3 });
-            await queue.connect();
-            await queue.enqueue([
-                { taskId: 1 }, { taskId: 2 }, { taskId: 3 }, { taskId: 4 }, { taskId: 5 },
-            ]);
-            await new Promise(resolve => setTimeout(resolve, 250));
-            expect(processing.length).toBeGreaterThanOrEqual(2);
-            await new Promise(resolve => setTimeout(resolve, 1500));
-            expect(completed.length).toBe(5);
-        });
-    });
-    describe('幂等性', () => {
-        it('应该支持在 data 中指定 id 来实现幂等性', async () => {
-            let processCount = 0;
-            const queue = createQueue(async () => {
-                processCount++;
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue({ id: 'unique-1', value: 1 });
-            await queue.enqueue({ id: 'unique-1', value: 2 });
-            await queue.enqueue({ id: 'unique-2', value: 3 });
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            expect(processCount).toBe(2); // 只处理 unique-1 和 unique-2
-        });
-    });
-    describe('延迟处理', () => {
-        it('应该支持延迟处理任务', async () => {
-            const startTime = Date.now();
-            let processTime = 0;
-            const queue = createQueue(async () => {
-                processTime = Date.now() - startTime;
-                return catchIt(() => { });
-            }, { processingDelay: 2000 });
-            await queue.connect();
-            await queue.enqueue({ test: true });
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            expect(processTime).toBe(0); // 还未处理
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            expect(processTime).toBeGreaterThanOrEqual(1900);
-        });
-    });
-});