@taicode/common-server 1.0.8 → 1.0.10

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

@@ -0,0 +1,836 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { catchIt } from '@taicode/common-base';
+import { RedisQueue } from './redis-queue';
+// Redis 连接配置
+const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
+describe('RedisQueue', () => {
+    let queue;
+    beforeEach(async () => {
+        // 为每个测试创建独立的队列实例，使用唯一的 key 避免冲突
+        const uniqueKey = `test:queue:${Date.now()}:${Math.random()}`;
+        queue = new RedisQueue({
+            redisUrl: REDIS_URL,
+            queueKey: uniqueKey,
+            consumerInterval: 100, // 更快的轮询间隔用于测试
+            maxRetries: 2,
+        });
+        await queue.connect();
+    });
+    afterEach(async () => {
+        // 清理：清空队列并断开连接
+        await queue.clear();
+        queue.disconnect();
+    });
+    describe('连接管理', () => {
+        it('应该成功连接到 Redis', async () => {
+            const health = await queue.health();
+            expect(health).toBe(true);
+        });
+        it('连接后应该自动启动消费者', async () => {
+            // 验证连接后消费者已经在运行
+            const stats = await queue.statistics();
+            expect(stats.pending + stats.processing).toBe(0);
+            // 添加任务后应该会被自动处理
+            let processed = false;
+            queue.handle('auto-task', async () => {
+                processed = true;
+                return catchIt(() => { });
+            });
+            await queue.enqueue('auto-task', { test: true });
+            await new Promise(resolve => setTimeout(resolve, 200));
+            expect(processed).toBe(true);
+        });
+    });
+    describe('任务入队', () => {
+        it('应该成功将任务推入队列', async () => {
+            const taskId = await queue.enqueue('test-task', { foo: 'bar' });
+            expect(taskId).toBeTruthy();
+            expect(taskId).toContain('test-task');
+            const stats = await queue.statistics();
+            expect(stats.pending + stats.processing).toBe(1);
+            expect(stats.pending).toBe(1);
+        });
+        it('应该能够批量入队任务', async () => {
+            const dataList = [
+                { value: 1 },
+                { value: 2 },
+                { value: 3 },
+            ];
+            const taskIds = await queue.enqueue('batch-task', dataList);
+            expect(taskIds).toHaveLength(3);
+            expect(taskIds.every(id => id.includes('batch-task'))).toBe(true);
+            const stats = await queue.statistics();
+            expect(stats.pending + stats.processing).toBe(3);
+            expect(stats.pending).toBe(3);
+        });
+        it('入队的任务应该包含正确的元数据', async () => {
+            const data = { test: 'data', number: 42 };
+            const taskId = await queue.enqueue('metadata-task', data);
+            const task = await queue.getTask(taskId);
+            expect(task).toBeTruthy();
+            expect(task?.id).toBe(taskId);
+            expect(task?.type).toBe('metadata-task');
+            expect(task?.data).toEqual(data);
+            expect(task?.status).toBe('pending');
+            expect(task?.retryCount).toBe(0);
+            expect(task?.maxRetries).toBe(2);
+            expect(task?.createdTime).toBeTruthy();
+        });
+    });
+    describe('任务处理', () => {
+        it('应该成功处理任务', async () => {
+            const processedData = [];
+            // 注册处理器
+            queue.handle('process-task', async (data) => {
+                processedData.push(data);
+                return catchIt(() => { });
+            });
+            // 入队任务
+            const taskId = await queue.enqueue('process-task', { value: 'test' });
+            // 等待任务处理完成（消费者已自动启动）
+            await new Promise(resolve => setTimeout(resolve, 500));
+            // 验证任务被处理
+            expect(processedData).toHaveLength(1);
+            expect(processedData[0]).toEqual({ value: 'test' });
+            // 验证任务状态
+            const task = await queue.getTask(taskId);
+            expect(task?.status).toBe('completed');
+            // 验证队列已空
+            const stats = await queue.statistics();
+            expect(stats.pending + stats.processing).toBe(0);
+        });
+        it('应该按 FIFO 顺序处理任务', async () => {
+            const processOrder = [];
+            queue.handle('order-task', async (data) => {
+                processOrder.push(data.order);
+                await new Promise(resolve => setTimeout(resolve, 50));
+                return catchIt(() => { });
+            });
+            // 入队多个任务,添加延迟以避免重复的 ID
+            await queue.enqueue('order-task', { order: 1 });
+            await new Promise(resolve => setTimeout(resolve, 5));
+            await queue.enqueue('order-task', { order: 2 });
+            await new Promise(resolve => setTimeout(resolve, 5));
+            await queue.enqueue('order-task', { order: 3 });
+            // 等待所有任务处理完成（消费者已自动启动）
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            expect(processOrder).toEqual([1, 2, 3]);
+        });
+        it('未注册处理器的任务应该标记为失败', async () => {
+            const taskId = await queue.enqueue('unhandled-task', { data: 'test' });
+            await new Promise(resolve => setTimeout(resolve, 500));
+            const task = await queue.getTask(taskId);
+            expect(task?.status).toBe('failed');
+        });
+    });
+    describe('错误处理和重试', () => {
+        it('失败的任务应该自动重试', async () => {
+            let attemptCount = 0;
+            queue.handle('retry-task', async () => {
+                attemptCount++;
+                if (attemptCount < 2) {
+                    throw new Error('Simulated failure');
+                }
+                // 第二次尝试成功
+                return catchIt(() => { });
+            });
+            const taskId = await queue.enqueue('retry-task', { test: 'retry' });
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            expect(attemptCount).toBe(2);
+            const task = await queue.getTask(taskId);
+            expect(task?.status).toBe('completed');
+            expect(task?.retryCount).toBe(1);
+        });
+        it('超过最大重试次数应该标记为失败', async () => {
+            let attemptCount = 0;
+            queue.handle('fail-task', async () => {
+                attemptCount++;
+                throw new Error('Always fails');
+                return catchIt(() => { });
+            });
+            const taskId = await queue.enqueue('fail-task', { test: 'fail' });
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            // maxRetries 是 2，所以总共会尝试 3 次（初始 + 2 次重试）
+            expect(attemptCount).toBe(3);
+            const task = await queue.getTask(taskId);
+            expect(task?.status).toBe('failed');
+            expect(task?.retryCount).toBe(2);
+        });
+        it('处理器抛出的错误不应该使消费者崩溃', async () => {
+            const processedTasks = [];
+            queue.handle('error-task', async (data) => {
+                if (data.id === 'fail') {
+                    throw new Error('Task failed');
+                }
+                processedTasks.push(data.id);
+                return catchIt(() => { });
+            });
+            // 添加延迟以避免重复的 ID
+            await queue.enqueue('error-task', { id: 'fail' });
+            await new Promise(resolve => setTimeout(resolve, 2));
+            await queue.enqueue('error-task', { id: 'success-1' });
+            await new Promise(resolve => setTimeout(resolve, 2));
+            await queue.enqueue('error-task', { id: 'success-2' });
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            // 即使第一个任务失败，后续任务仍应被处理
+            expect(processedTasks).toContain('success-1');
+            expect(processedTasks).toContain('success-2');
+        });
+    });
+    describe('消费者管理', () => {
+        it('连接后消费者应该自动处理任务', async () => {
+            let processCount = 0;
+            queue.handle('consumer-task', async () => {
+                processCount++;
+                return catchIt(() => { });
+            });
+            await queue.enqueue('consumer-task', { test: 1 });
+            await new Promise(resolve => setTimeout(resolve, 300));
+            // 任务应该被自动处理
+            expect(processCount).toBe(1);
+        });
+        it('断开连接后消费者应该停止', async () => {
+            let processCount = 0;
+            queue.handle('consumer-task', async () => {
+                processCount++;
+                return catchIt(() => { });
+            });
+            await queue.enqueue('consumer-task', { test: 1 });
+            await new Promise(resolve => setTimeout(resolve, 300));
+            expect(processCount).toBe(1);
+            // 断开连接
+            queue.disconnect();
+            // 重新连接并注册处理器
+            await queue.connect();
+            queue.handle('consumer-task', async () => {
+                processCount++;
+                return catchIt(() => { });
+            });
+            await queue.enqueue('consumer-task', { test: 2 });
+            await new Promise(resolve => setTimeout(resolve, 300));
+            // 新任务应该被处理
+            expect(processCount).toBe(2);
+        });
+    });
+    describe('队列操作', () => {
+        it('应该正确返回队列统计信息', async () => {
+            let stats = await queue.statistics();
+            expect(stats.pending + stats.processing).toBe(0);
+            expect(stats.pending).toBe(0);
+            await queue.enqueue('task-1', { data: 1 });
+            stats = await queue.statistics();
+            expect(stats.pending + stats.processing).toBe(1);
+            expect(stats.pending).toBe(1);
+            await queue.enqueue('task-2', { data: 2 });
+            stats = await queue.statistics();
+            expect(stats.pending + stats.processing).toBe(2);
+            expect(stats.pending).toBe(2);
+            await queue.enqueue('task-3', { data: 3 });
+            stats = await queue.statistics();
+            expect(stats.pending + stats.processing).toBe(3);
+            expect(stats.pending).toBe(3);
+            // 注册处理器并等待部分任务处理
+            let processedCount = 0;
+            queue.handle('task-1', async () => {
+                processedCount++;
+                await new Promise(resolve => setTimeout(resolve, 100));
+                return catchIt(() => { });
+            });
+            queue.handle('task-2', async () => {
+                processedCount++;
+                await new Promise(resolve => setTimeout(resolve, 100));
+                return catchIt(() => { });
+            });
+            // 等待任务处理
+            await new Promise(resolve => setTimeout(resolve, 300));
+            // 验证处理后的状态
+            expect(processedCount).toBeGreaterThan(0);
+        });
+        it('应该能够清空队列', async () => {
+            await queue.enqueue('task-1', { data: 1 });
+            await queue.enqueue('task-2', { data: 2 });
+            await queue.enqueue('task-3', { data: 3 });
+            let stats = await queue.statistics();
+            expect(stats.pending + stats.processing).toBe(3);
+            await queue.clear();
+            stats = await queue.statistics();
+            expect(stats.pending + stats.processing).toBe(0);
+        });
+        it('应该能够获取任务详情', async () => {
+            const taskId = await queue.enqueue('detail-task', { foo: 'bar' });
+            const task = await queue.getTask(taskId);
+            expect(task).not.toBeNull();
+            expect(task?.id).toBe(taskId);
+            expect(task?.type).toBe('detail-task');
+            expect(task?.data).toEqual({ foo: 'bar' });
+        });
+        it('获取不存在的任务应该返回 null', async () => {
+            const task = await queue.getTask('non-existent-task-id');
+            expect(task).toBeNull();
+        });
+    });
+    describe('复杂场景', () => {
+        it('应该能够处理多种类型的任务', async () => {
+            const emailsSent = [];
+            const smssSent = [];
+            queue.handle('send-email', async (data) => {
+                emailsSent.push(data);
+                return catchIt(() => { });
+            });
+            queue.handle('send-sms', async (data) => {
+                smssSent.push(data);
+                return catchIt(() => { });
+            });
+            await queue.enqueue('send-email', { to: 'user1@example.com' });
+            await queue.enqueue('send-sms', { phone: '123456789' });
+            await queue.enqueue('send-email', { to: 'user2@example.com' });
+            await new Promise(resolve => setTimeout(resolve, 800));
+            expect(emailsSent).toHaveLength(2);
+            expect(smssSent).toHaveLength(1);
+        });
+        it('应该能够处理大量并发任务', async () => {
+            const processedIds = new Set();
+            queue.handle('concurrent-task', async (data) => {
+                await new Promise(resolve => setTimeout(resolve, 10));
+                processedIds.add(data.id);
+                return catchIt(() => { });
+            });
+            // 入队 50 个任务
+            const promises = [];
+            for (let i = 0; i < 50; i++) {
+                promises.push(queue.enqueue('concurrent-task', { id: `task-${i}` }));
+            }
+            await Promise.all(promises);
+            // 等待所有任务处理完成
+            await new Promise(resolve => setTimeout(resolve, 8000));
+            expect(processedIds.size).toBe(50);
+            const stats = await queue.statistics();
+            expect(stats.pending + stats.processing).toBe(0);
+        }, 10000); // 增加超时到10秒
+        it('应该能够处理包含复杂数据的任务', async () => {
+            const processedData = [];
+            queue.handle('complex-task', async (data) => {
+                processedData.push(data);
+                return catchIt(() => { });
+            });
+            const complexData = {
+                user: {
+                    id: 123,
+                    name: 'Test User',
+                    preferences: {
+                        theme: 'dark',
+                        notifications: true,
+                    },
+                },
+                items: [
+                    { id: 1, name: 'Item 1' },
+                    { id: 2, name: 'Item 2' },
+                ],
+                metadata: {
+                    timestamp: new Date().toISOString(),
+                    source: 'test',
+                },
+            };
+            await queue.enqueue('complex-task', complexData);
+            await new Promise(resolve => setTimeout(resolve, 500));
+            expect(processedData).toHaveLength(1);
+            expect(processedData[0]).toEqual(complexData);
+        });
+    });
+    describe('边界情况', () => {
+        it('应该支持并发处理多个任务', async () => {
+            // 创建一个支持并发的队列
+            const concurrentQueue = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey: `test:queue:concurrent:${Date.now()}:${Math.random()}`,
+                concurrency: 3, // 并发处理 3 个任务
+                consumerInterval: 50, // 更快的轮询
+                maxRetries: 2,
+            });
+            await concurrentQueue.connect();
+            const processing = [];
+            const completed = [];
+            const processStartTimes = {};
+            concurrentQueue.handle('concurrent-test', async (data) => {
+                processStartTimes[data.id] = Date.now();
+                processing.push(data.id);
+                await new Promise(resolve => setTimeout(resolve, 400)); // 模拟耗时操作
+                completed.push(data.id);
+                return catchIt(() => { });
+            });
+            // 添加 5 个任务
+            await concurrentQueue.enqueue('concurrent-test', [
+                { id: 'task-1' },
+                { id: 'task-2' },
+                { id: 'task-3' },
+                { id: 'task-4' },
+                { id: 'task-5' },
+            ]);
+            // 等待一小段时间，应该有多个任务同时在处理
+            await new Promise(resolve => setTimeout(resolve, 250));
+            expect(processing.length).toBeGreaterThanOrEqual(2); // 至少有 2 个任务在处理
+            expect(completed.length).toBeLessThan(processing.length); // 还有任务未完成
+            // 等待所有任务完成
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            // 验证所有任务都完成了
+            const stats = await concurrentQueue.statistics();
+            expect(stats.completed).toBe(5);
+            expect(completed.length).toBe(5);
+            // 清理
+            await concurrentQueue.clear();
+            concurrentQueue.disconnect();
+        });
+        it('应该能够恢复超时的任务', async () => {
+            const queueKey = `test:queue:recovery:${Date.now()}`;
+            // 创建一个处理超时时间很短的队列（2秒）
+            const queue1 = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey,
+                consumerInterval: 50,
+                maxRetries: 2,
+                processingTimeout: 2000, // 2秒处理超时
+            });
+            await queue1.connect();
+            let taskStarted = false;
+            queue1.handle('recovery-task', async (data) => {
+                taskStarted = true;
+                // 模拟一个永远不会完成的任务
+                await new Promise(resolve => setTimeout(resolve, 10000));
+                return catchIt(() => { });
+            });
+            // 添加任务
+            await queue1.enqueue('recovery-task', { id: 'task-1' });
+            // 等待任务开始处理
+            await new Promise(resolve => setTimeout(resolve, 200));
+            expect(taskStarted).toBe(true);
+            // 检查任务应该在 processing 队列中
+            const redis = await import('redis');
+            const testClient = redis.createClient({ url: REDIS_URL });
+            await testClient.connect();
+            let processingCount = await testClient.lLen(`${queueKey}:processing`);
+            expect(processingCount).toBe(1);
+            // 模拟程序崩溃，直接断开（不等待任务完成）
+            queue1.disconnect();
+            // 等待处理超时（超过 2 秒）+ 恢复机制检查时间
+            await new Promise(resolve => setTimeout(resolve, 3000));
+            // 创建新的队列实例，应该检测到超时并恢复任务
+            const queue2 = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey,
+                consumerInterval: 50,
+                maxRetries: 2,
+                processingTimeout: 2000,
+            });
+            let recovered = false;
+            queue2.handle('recovery-task', async () => {
+                recovered = true;
+                return catchIt(() => { });
+            });
+            await queue2.connect();
+            // 等待任务被恢复并处理（恢复机制立即执行一次）
+            await new Promise(resolve => setTimeout(resolve, 500));
+            // 任务应该被恢复并处理
+            expect(recovered).toBe(true);
+            // 清理
+            await testClient.disconnect();
+            await queue2.clear();
+            queue2.disconnect();
+        });
+        it('缺少必填参数应该抛出错误', () => {
+            // 缺少 redisUrl
+            expect(() => new RedisQueue({
+                redisUrl: '',
+                queueKey: 'test:queue',
+            })).toThrow('[TaskQueue] redisUrl is required');
+            // 缺少 queueKey
+            expect(() => new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey: '',
+            })).toThrow('[TaskQueue] queueKey is required');
+            // queueKey 太短
+            expect(() => new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey: 'short',
+            })).toThrow('[TaskQueue] queueKey must be at least 6 characters long');
+        });
+        it('应该能够处理空数据的任务', async () => {
+            let processed = false;
+            queue.handle('empty-data-task', async (data) => {
+                expect(data).toEqual({});
+                processed = true;
+                return catchIt(() => { });
+            });
+            await queue.enqueue('empty-data-task', {});
+            await new Promise(resolve => setTimeout(resolve, 500));
+            expect(processed).toBe(true);
+        });
+        it('任务 ID 应该是唯一的', async () => {
+            const ids = new Set();
+            for (let i = 0; i < 10; i++) {
+                const id = await queue.enqueue('unique-id-task', { index: i });
+                ids.add(id);
+                // 添加小延迟确保时间戳不同
+                await new Promise(resolve => setTimeout(resolve, 2));
+            }
+            // 所有 ID 应该都是唯一的
+            expect(ids.size).toBe(10);
+        });
+        it('应该支持在 data 中指定 id 来实现幂等性', async () => {
+            const queue = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey: `test-idempotent-${Date.now()}`, // 使用唯一 key 避免干扰
+            });
+            await queue.connect();
+            let processCount = 0;
+            queue.handle('idempotent-task', async () => {
+                processCount++;
+                return catchIt(() => { });
+            });
+            // 在 data 中指定相同的 id 多次入队
+            const id1 = await queue.enqueue('idempotent-task', { id: 'my-unique-id', value: 1 });
+            const id2 = await queue.enqueue('idempotent-task', { id: 'my-unique-id', value: 2 });
+            const id3 = await queue.enqueue('idempotent-task', { id: 'my-unique-id', value: 3 });
+            // 应该返回相同的完整 ID
+            expect(id1).toBe('idempotent-task:my-unique-id');
+            expect(id2).toBe('idempotent-task:my-unique-id');
+            expect(id3).toBe('idempotent-task:my-unique-id');
+            // 等待任务处理
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            // 应该只处理一次
+            expect(processCount).toBe(1);
+            // 检查统计信息
+            const stats = await queue.statistics();
+            expect(stats.pending).toBe(0);
+            expect(stats.processing).toBe(0);
+            expect(stats.completed).toBe(1);
+            queue.disconnect();
+        });
+        it('data 中不指定 id 时应该自动生成唯一 ID', async () => {
+            const queue = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey: `test-auto-id-${Date.now()}`, // 使用唯一 key 避免干扰
+            });
+            await queue.connect();
+            let processCount = 0;
+            queue.handle('auto-id-task', async () => {
+                processCount++;
+                return catchIt(() => { });
+            });
+            // 不指定 id,多次入队相同数据
+            const id1 = await queue.enqueue('auto-id-task', { value: 1 });
+            const id2 = await queue.enqueue('auto-id-task', { value: 1 });
+            const id3 = await queue.enqueue('auto-id-task', { value: 1 });
+            // ID 应该都不相同
+            expect(id1).not.toBe(id2);
+            expect(id2).not.toBe(id3);
+            expect(id1).not.toBe(id3);
+            // 等待任务处理
+            await new Promise(resolve => setTimeout(resolve, 3500));
+            // 应该处理 3 次
+            expect(processCount).toBe(3);
+            queue.disconnect();
+        });
+        it('应该支持延迟处理任务', async () => {
+            const queue = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey: `test-delay-${Date.now()}`,
+                processingDelay: 2000, // 延迟 2 秒处理
+            });
+            await queue.connect();
+            let processCount = 0;
+            let processTime = 0;
+            const startTime = Date.now();
+            queue.handle('delay-task', async () => {
+                processCount++;
+                processTime = Date.now() - startTime;
+                return catchIt(() => { });
+            });
+            // 入队任务
+            await queue.enqueue('delay-task', { value: 1 });
+            // 等待 1 秒,任务应该还未处理
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            expect(processCount).toBe(0);
+            // 再等待 2 秒,任务应该已处理
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            expect(processCount).toBe(1);
+            // 验证处理时间大约在 2 秒左右(允许一定误差)
+            expect(processTime).toBeGreaterThanOrEqual(1900);
+            expect(processTime).toBeLessThanOrEqual(3000);
+            queue.disconnect();
+        });
+        it('延迟处理应该能增强幂等性去重效果', async () => {
+            const queue = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey: `test-delay-mix-${Date.now()}`,
+                processingDelay: 1500, // 延迟 1.5 秒处理
+            });
+            await queue.connect();
+            let processCount = 0;
+            queue.handle('delayed-idempotent', async () => {
+                processCount++;
+                return catchIt(() => { });
+            });
+            // 快速连续入队 3 次相同 ID 的任务
+            await queue.enqueue('delayed-idempotent', { id: 'unique-123', value: 1 });
+            await new Promise(resolve => setTimeout(resolve, 100));
+            await queue.enqueue('delayed-idempotent', { id: 'unique-123', value: 2 });
+            await new Promise(resolve => setTimeout(resolve, 100));
+            await queue.enqueue('delayed-idempotent', { id: 'unique-123', value: 3 });
+            // 等待延迟时间 + 处理时间
+            await new Promise(resolve => setTimeout(resolve, 2500));
+            // 应该只处理一次
+            expect(processCount).toBe(1);
+            queue.disconnect();
+        });
+        it('pending 状态超时的任务应该被标记为失败', async () => {
+            const queue = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey: `test-pending-timeout-${Date.now()}`,
+            });
+            await queue.connect();
+            // 不注册处理器,任务会一直在 pending
+            // 但我们会手动修改任务状态来模拟超时场景
+            const taskId = await queue.enqueue('timeout-task', { value: 1 });
+            // 获取任务并手动修改为已处理状态(模拟异常情况)
+            const task = await queue.getTask(taskId);
+            if (task) {
+                task.status = 'completed'; // 模拟任务状态异常
+                const taskKey = `test-pending-timeout-${Date.now()}:task:${taskId}`;
+                // 这里我们不直接修改 Redis,而是让消费者发现状态异常
+            }
+            // 注册处理器(但任务状态已经不是 pending 了)
+            let failedCount = 0;
+            queue.handle('timeout-task', async () => {
+                return catchIt(() => { });
+            });
+            // 等待消费者处理
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            // 检查失败队列
+            const stats = await queue.statistics();
+            // 由于任务状态不是 pending,应该被标记为失败
+            expect(stats.failed).toBeGreaterThanOrEqual(0);
+            queue.disconnect();
+        });
+    });
+    describe('并发安全性', () => {
+        it('多个队列实例应该能安全地处理相同的任务', async () => {
+            const queueKey = `test-concurrent-instances-${Date.now()}`;
+            const queue1 = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey,
+                consumerInterval: 50,
+            });
+            const queue2 = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey,
+                consumerInterval: 50,
+            });
+            await queue1.connect();
+            await queue2.connect();
+            let processCount = 0;
+            const processedIds = new Set();
+            const handler = async (data) => {
+                processCount++;
+                processedIds.add(`${data.value}`);
+                await new Promise(resolve => setTimeout(resolve, 100)); // 模拟处理时间
+                return catchIt(() => { });
+            };
+            queue1.handle('concurrent-task', handler);
+            queue2.handle('concurrent-task', handler);
+            // 添加 10 个任务
+            await queue1.enqueue('concurrent-task', Array.from({ length: 10 }, (_, i) => ({ value: i })));
+            // 等待所有任务处理完成
+            await new Promise(resolve => setTimeout(resolve, 3000));
+            // 每个任务应该只被处理一次
+            expect(processCount).toBe(10);
+            expect(processedIds.size).toBe(10);
+            queue1.disconnect();
+            queue2.disconnect();
+        });
+        it('幂等性入队应该在并发场景下工作正常', async () => {
+            const queueKey = `test-concurrent-enqueue-${Date.now()}`;
+            const queue1 = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey,
+            });
+            const queue2 = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey,
+            });
+            await queue1.connect();
+            await queue2.connect();
+            let processCount = 0;
+            const handler = async (_data) => {
+                processCount++;
+                return catchIt(() => { });
+            };
+            queue1.handle('idempotent-concurrent', handler);
+            queue2.handle('idempotent-concurrent', handler);
+            // 两个实例同时入队相同 ID 的任务
+            await Promise.all([
+                queue1.enqueue('idempotent-concurrent', { id: 'same-id', value: 1 }),
+                queue2.enqueue('idempotent-concurrent', { id: 'same-id', value: 2 }),
+                queue1.enqueue('idempotent-concurrent', { id: 'same-id', value: 3 }),
+                queue2.enqueue('idempotent-concurrent', { id: 'same-id', value: 4 }),
+            ]);
+            // 等待处理
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            // 应该只处理一次
+            expect(processCount).toBe(1);
+            queue1.disconnect();
+            queue2.disconnect();
+        });
+    });
+    describe('数据边界测试', () => {
+        it('应该能够处理大数据量的任务', async () => {
+            const queue = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey: `test-large-data-${Date.now()}`,
+            });
+            await queue.connect();
+            let processed = false;
+            const largeData = {
+                id: 'large',
+                content: 'x'.repeat(10000), // 10KB 数据
+                array: Array.from({ length: 100 }, (_, i) => ({ index: i, value: `item-${i}` })),
+            };
+            queue.handle('large-data-task', async (data) => {
+                expect(data.content.length).toBe(10000);
+                expect(data.array.length).toBe(100);
+                processed = true;
+                return catchIt(() => { });
+            });
+            await queue.enqueue('large-data-task', largeData);
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            expect(processed).toBe(true);
+            queue.disconnect();
+        });
+    });
+    describe('恢复机制边界测试', () => {
+        it('应该在达到最大重试次数后停止重试', async () => {
+            const queueKey = `test-max-retries-${Date.now()}`;
+            const queue = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey,
+                processingTimeout: 500,
+                maxRetries: 2,
+            });
+            await queue.connect();
+            let attemptCount = 0;
+            queue.handle('retry-limit', async () => {
+                attemptCount++;
+                // 永远失败
+                throw new Error('Always fails');
+            });
+            await queue.enqueue('retry-limit', { test: true });
+            // 等待所有重试完成
+            await new Promise(resolve => setTimeout(resolve, 4000));
+            // 应该至少尝试 1 次,最多 3 次(初始 + 2 次重试)
+            expect(attemptCount).toBeGreaterThanOrEqual(1);
+            expect(attemptCount).toBeLessThanOrEqual(3);
+            queue.disconnect();
+        });
+    });
+    describe('延迟任务边界测试', () => {
+        it('延迟时间为 0 应该立即处理', async () => {
+            const queue = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey: `test-zero-delay-${Date.now()}`,
+                processingDelay: 0,
+            });
+            await queue.connect();
+            const startTime = Date.now();
+            let processTime = 0;
+            queue.handle('zero-delay', async () => {
+                processTime = Date.now() - startTime;
+                return catchIt(() => { });
+            });
+            await queue.enqueue('zero-delay', { test: true });
+            await new Promise(resolve => setTimeout(resolve, 500));
+            // 应该在 500ms 内处理(立即处理)
+            expect(processTime).toBeLessThan(500);
+            queue.disconnect();
+        });
+        it('应该按延迟顺序处理任务', async () => {
+            const queue = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey: `test-delay-order-${Date.now()}`,
+                consumerInterval: 100,
+            });
+            await queue.connect();
+            const processedOrder = [];
+            const processTimes = [];
+            const startTime = Date.now();
+            queue.handle('delay-order', async (data) => {
+                processedOrder.push(data.id);
+                processTimes.push(Date.now() - startTime);
+                return catchIt(() => { });
+            });
+            // 入队时手动设置不同的延迟时间
+            const task1Id = await queue.enqueue('delay-order', { id: '1', value: 1 });
+            const task2Id = await queue.enqueue('delay-order', { id: '2', value: 2 });
+            const task3Id = await queue.enqueue('delay-order', { id: '3', value: 3 });
+            // 手动修改任务的 delayUntil
+            const now = Date.now();
+            const redis = await import('redis');
+            const client = redis.createClient({ url: REDIS_URL });
+            await client.connect();
+            const task1 = await queue.getTask(task1Id);
+            const task2 = await queue.getTask(task2Id);
+            const task3 = await queue.getTask(task3Id);
+            if (task1 && task2 && task3) {
+                task1.delayUntil = now + 2000; // 2 秒后
+                task2.delayUntil = now + 500; // 0.5 秒后
+                task3.delayUntil = now + 1000; // 1 秒后
+                const queueKey = queue['config'].queueKey;
+                await client.setEx(`${queueKey}:task:${task1Id}`, 3600, JSON.stringify(task1));
+                await client.setEx(`${queueKey}:task:${task2Id}`, 3600, JSON.stringify(task2));
+                await client.setEx(`${queueKey}:task:${task3Id}`, 3600, JSON.stringify(task3));
+            }
+            await client.disconnect();
+            // 等待所有任务处理完成
+            await new Promise(resolve => setTimeout(resolve, 3500));
+            // 应该按延迟顺序处理: 2 -> 3 -> 1
+            expect(processedOrder).toEqual(['2', '3', '1']);
+            // 验证处理时间也符合预期
+            expect(processTimes[0]).toBeGreaterThanOrEqual(400);
+            expect(processTimes[1]).toBeGreaterThanOrEqual(900);
+            expect(processTimes[2]).toBeGreaterThanOrEqual(1900);
+            queue.disconnect();
+        }, 10000);
+    });
+    describe('清空队列操作', () => {
+        it('清空队列应该删除所有状态的任务', async () => {
+            const queue = new RedisQueue({
+                redisUrl: REDIS_URL,
+                queueKey: `test-clear-all-${Date.now()}`,
+            });
+            await queue.connect();
+            // 添加不同状态的任务
+            queue.handle('clear-test', async (data) => {
+                if (data.shouldFail) {
+                    throw new Error('Intentional failure');
+                }
+                return catchIt(() => { });
+            });
+            await queue.enqueue('clear-test', [
+                { shouldFail: false },
+                { shouldFail: false },
+                { shouldFail: true },
+            ]);
+            // 等待部分处理
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            const statsBefore = await queue.statistics();
+            const totalBefore = statsBefore.pending + statsBefore.processing + statsBefore.completed + statsBefore.failed;
+            expect(totalBefore).toBeGreaterThan(0);
+            // 清空队列
+            await queue.clear();
+            const statsAfter = await queue.statistics();
+            expect(statsAfter.pending).toBe(0);
+            expect(statsAfter.processing).toBe(0);
+            expect(statsAfter.completed).toBe(0);
+            expect(statsAfter.failed).toBe(0);
+            queue.disconnect();
+        });
+    });
+});