@taicode/common-server 1.0.11 → 1.0.13

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

@@ -0,0 +1,623 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { RedisQueueCommon } from './redis-queue-common';
+const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
+// 创建一个具体的测试类来测试抽象基类
+class TestRedisQueueCommon extends RedisQueueCommon {
+    getLogPrefix() {
+        return 'TestRedisQueue';
+    }
+    // 暴露 protected 方法用于测试
+    testGetTask(taskId) {
+        return this.getTask(taskId);
+    }
+    testGetQueueByStatus(status) {
+        return this.getQueueByStatus(status);
+    }
+    async testApplyStatus(taskId, oldStatus, newStatus) {
+        return this.applyStatus(taskId, oldStatus, newStatus);
+    }
+    getRedisClient() {
+        return this.redis;
+    }
+    getConfig() {
+        return {
+            queueKey: this.queueKey,
+            redisUrl: this.redisUrl,
+            cleanupDelay: this.cleanupDelay,
+            pendingQueue: this.pendingQueue,
+            processingQueue: this.processingQueue,
+            completedQueue: this.completedQueue,
+            failedQueue: this.failedQueue,
+        };
+    }
+}
+describe('RedisQueueCommon', () => {
+    let instance;
+    const queueKey = `test:common:${Date.now()}:${Math.random()}`;
+    beforeEach(async () => {
+        instance = new TestRedisQueueCommon({
+            redisUrl: REDIS_URL,
+            queueKey,
+            cleanupDelay: 3600,
+        });
+        await instance.connect();
+    });
+    afterEach(async () => {
+        // 清理测试数据
+        if (instance['redis'] && instance['redis'].isOpen) {
+            const allKeys = await instance['redis'].keys(`${queueKey}:*`);
+            if (allKeys.length > 0) {
+                await instance['redis'].del(allKeys);
+            }
+            await instance['redis'].del([
+                `${queueKey}:pending`,
+                `${queueKey}:processing`,
+                `${queueKey}:completed`,
+                `${queueKey}:failed`,
+            ]);
+        }
+        if (instance['redis']?.isOpen) {
+            instance.disconnect();
+        }
+    });
+    describe('连接管理', () => {
+        it('应该成功连接到 Redis', async () => {
+            expect(instance['redis']).toBeDefined();
+            expect(instance['redis']?.isOpen).toBe(true);
+        });
+        it('应该成功断开连接', async () => {
+            instance.disconnect();
+            expect(instance['redis']?.isOpen).toBe(false);
+        });
+        it('应该初始化正确的队列键名', () => {
+            expect(instance['pendingQueue']).toBe(`${queueKey}:pending`);
+            expect(instance['processingQueue']).toBe(`${queueKey}:processing`);
+            expect(instance['completedQueue']).toBe(`${queueKey}:completed`);
+            expect(instance['failedQueue']).toBe(`${queueKey}:failed`);
+        });
+    });
+    describe('getTask', () => {
+        it('应该能获取存在的任务', async () => {
+            const taskId = 'test-task-1';
+            const task = {
+                id: taskId,
+                data: { message: 'test' },
+                retryCount: 0,
+                maxRetries: 3,
+                createdTime: new Date().toISOString(),
+                status: 'pending',
+            };
+            // 手动存储任务
+            const taskKey = `${queueKey}:task:${taskId}`;
+            await instance['redis'].setEx(taskKey, 3600, JSON.stringify(task));
+            const result = await instance['getTask'](taskId);
+            expect(result).toEqual(task);
+        });
+        it('应该在任务不存在时返回 null', async () => {
+            const result = await instance['getTask']('non-existent-task');
+            expect(result).toBe(null);
+        });
+        it('应该在 Redis 未连接时返回 null', async () => {
+            instance.disconnect();
+            // 等待断开连接完成
+            await new Promise(resolve => setTimeout(resolve, 50));
+            const result = await instance['getTask']('any-task');
+            expect(result).toBe(null);
+        });
+    });
+    describe('applyStatus', () => {
+        const taskId = 'test-task-status';
+        beforeEach(async () => {
+            // 创建测试任务
+            const task = {
+                id: taskId,
+                data: { message: 'test' },
+                retryCount: 0,
+                maxRetries: 3,
+                createdTime: new Date().toISOString(),
+                status: 'pending',
+            };
+            const taskKey = `${queueKey}:task:${taskId}`;
+            await instance['redis'].setEx(taskKey, 3600, JSON.stringify(task));
+            await instance['redis'].rPush(instance['pendingQueue'], taskId);
+        });
+        it('应该能将任务状态更新为 processing', async () => {
+            await instance['applyStatus'](taskId, 'pending', 'processing');
+            const task = await instance['getTask'](taskId);
+            expect(task?.status).toBe('processing');
+            // 验证任务在正确的队列中
+            const processingTasks = await instance['redis'].lRange(instance['processingQueue'], 0, -1);
+            expect(processingTasks).toContain(taskId);
+        });
+        it('应该能将任务状态更新为 completed', async () => {
+            await instance['applyStatus'](taskId, 'pending', 'completed');
+            const task = await instance['getTask'](taskId);
+            expect(task?.status).toBe('completed');
+            const completedTasks = await instance['redis'].lRange(instance['completedQueue'], 0, -1);
+            expect(completedTasks).toContain(taskId);
+        });
+        it('应该能将任务状态更新为 failed', async () => {
+            await instance['applyStatus'](taskId, 'pending', 'failed');
+            const task = await instance['getTask'](taskId);
+            expect(task?.status).toBe('failed');
+            const failedTasks = await instance['redis'].lRange(instance['failedQueue'], 0, -1);
+            expect(failedTasks).toContain(taskId);
+        });
+        it('应该在 Redis 未连接时不执行任何操作', async () => {
+            instance.disconnect();
+            // 等待断开连接完成
+            await new Promise(resolve => setTimeout(resolve, 50));
+            await instance['applyStatus'](taskId, 'pending', 'completed');
+            // 不应该抛出错误
+        });
+    });
+    describe('getQueueByStatus', () => {
+        it('应该返回 pending 队列的键名', () => {
+            const queueKey = instance['getQueueByStatus']('pending');
+            expect(queueKey).toBe(`${instance['queueKey']}:pending`);
+        });
+        it('应该返回 processing 队列的键名', () => {
+            const queueKey = instance['getQueueByStatus']('processing');
+            expect(queueKey).toBe(`${instance['queueKey']}:processing`);
+        });
+        it('应该返回 completed 队列的键名', () => {
+            const queueKey = instance['getQueueByStatus']('completed');
+            expect(queueKey).toBe(`${instance['queueKey']}:completed`);
+        });
+        it('应该返回 failed 队列的键名', () => {
+            const queueKey = instance['getQueueByStatus']('failed');
+            expect(queueKey).toBe(`${instance['queueKey']}:failed`);
+        });
+    });
+    describe('statistics', () => {
+        it('应该返回正确的队列统计信息', async () => {
+            // 创建不同状态的任务
+            const taskIds = {
+                pending: ['p1', 'p2'],
+                processing: ['pr1'],
+                completed: ['c1', 'c2', 'c3'],
+                failed: ['f1'],
+            };
+            // 添加任务到各个队列
+            for (const [status, ids] of Object.entries(taskIds)) {
+                const queueName = `${queueKey}:${status}`;
+                for (const id of ids) {
+                    await instance['redis'].rPush(queueName, id);
+                }
+            }
+            const stats = await instance.statistics();
+            expect(stats).toEqual({
+                pending: 2,
+                processing: 1,
+                completed: 3,
+                failed: 1,
+            });
+        });
+        it('应该在所有队列为空时返回全零统计', async () => {
+            const stats = await instance.statistics();
+            expect(stats).toEqual({
+                pending: 0,
+                processing: 0,
+                completed: 0,
+                failed: 0,
+            });
+        });
+        it('应该在 Redis 未连接时返回全零统计', async () => {
+            instance.disconnect();
+            // 等待断开连接完成
+            await new Promise(resolve => setTimeout(resolve, 50));
+            const stats = await instance.statistics();
+            expect(stats).toEqual({
+                pending: 0,
+                processing: 0,
+                completed: 0,
+                failed: 0,
+            });
+        });
+    });
+    describe('health', () => {
+        it('应该在 Redis 连接正常时返回 true', async () => {
+            const health = await instance.health();
+            expect(health).toBe(true);
+        });
+        it('应该在 Redis 未连接时返回 false', async () => {
+            instance.disconnect();
+            // 等待断开连接完成
+            await new Promise(resolve => setTimeout(resolve, 50));
+            const health = await instance.health();
+            expect(health).toBe(false);
+        });
+    });
+    describe('队列键名验证', () => {
+        it('应该拒绝长度小于6的 queueKey', () => {
+            expect(() => {
+                new TestRedisQueueCommon({
+                    redisUrl: REDIS_URL,
+                    queueKey: 'short',
+                    cleanupDelay: 3600,
+                });
+            }).toThrow('queueKey must be at least 6 characters long');
+        });
+        it('应该接受长度大于等于6的 queueKey', () => {
+            expect(() => {
+                new TestRedisQueueCommon({
+                    redisUrl: REDIS_URL,
+                    queueKey: 'valid-key',
+                    cleanupDelay: 3600,
+                });
+            }).not.toThrow();
+        });
+    });
+    describe('cleanupDelay 配置', () => {
+        it('应该使用默认的 cleanupDelay', () => {
+            const defaultInstance = new TestRedisQueueCommon({
+                redisUrl: REDIS_URL,
+                queueKey: 'test-default',
+            });
+            expect(defaultInstance['cleanupDelay']).toBe(86400); // 默认 24 小时
+        });
+        it('应该使用自定义的 cleanupDelay', () => {
+            const customInstance = new TestRedisQueueCommon({
+                redisUrl: REDIS_URL,
+                queueKey: 'test-custom',
+                cleanupDelay: 7200,
+            });
+            expect(customInstance['cleanupDelay']).toBe(7200);
+        });
+    });
+    describe('构造函数参数验证', () => {
+        it('应该拒绝空的 redisUrl 和 redisClient', () => {
+            expect(() => {
+                new TestRedisQueueCommon({
+                    redisUrl: '',
+                    queueKey: 'test-queue',
+                });
+            }).toThrow('Either redisUrl or redisClient is required');
+        });
+        it('应该拒绝空的 queueKey', () => {
+            expect(() => {
+                new TestRedisQueueCommon({
+                    redisUrl: REDIS_URL,
+                    queueKey: '',
+                });
+            }).toThrow('queueKey is required');
+        });
+        it('应该正确初始化所有队列键名', () => {
+            const testQueue = new TestRedisQueueCommon({
+                redisUrl: REDIS_URL,
+                queueKey: 'my-queue',
+            });
+            const config = testQueue.getConfig();
+            expect(config.pendingQueue).toBe('my-queue:pending');
+            expect(config.processingQueue).toBe('my-queue:processing');
+            expect(config.completedQueue).toBe('my-queue:completed');
+            expect(config.failedQueue).toBe('my-queue:failed');
+        });
+    });
+    describe('连接状态管理', () => {
+        it('应该能够重复连接', async () => {
+            await instance.connect();
+            await instance.connect();
+            expect(instance.getRedisClient()?.isOpen).toBe(true);
+        });
+        it('应该能够在断开后重新连接', async () => {
+            instance.disconnect();
+            await new Promise(resolve => setTimeout(resolve, 100));
+            const newInstance = new TestRedisQueueCommon({
+                redisUrl: REDIS_URL,
+                queueKey: `test:reconnect:${Date.now()}`,
+            });
+            await newInstance.connect();
+            expect(newInstance.getRedisClient()?.isOpen).toBe(true);
+            newInstance.disconnect();
+        });
+        it('应该正确处理 Redis 错误事件', async () => {
+            const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            // 创建一个带有错误的实例
+            const errorInstance = new TestRedisQueueCommon({
+                redisUrl: REDIS_URL,
+                queueKey: 'test-error',
+            });
+            // 模拟 Redis 错误
+            const redis = errorInstance.getRedisClient();
+            if (redis) {
+                redis.emit('error', new Error('Test error'));
+            }
+            // 验证错误被记录
+            expect(errorSpy).toHaveBeenCalled();
+            errorSpy.mockRestore();
+        });
+    });
+    describe('getTask 边界测试', () => {
+        it('应该处理不存在的任务ID', async () => {
+            const task = await instance.testGetTask('non-existent-id');
+            expect(task).toBeNull();
+        });
+        it('应该处理无效的JSON数据', async () => {
+            const taskId = 'invalid-json-task';
+            const taskKey = `${queueKey}:task:${taskId}`;
+            // 直接写入无效的JSON
+            await instance.getRedisClient()?.set(taskKey, 'invalid json {');
+            // 应该抛出错误或返回 null
+            await expect(instance.testGetTask(taskId)).rejects.toThrow();
+        });
+        it('应该正确解析包含特殊字符的任务数据', async () => {
+            const taskId = 'special-char-task';
+            const taskKey = `${queueKey}:task:${taskId}`;
+            const specialTask = {
+                id: taskId,
+                data: {
+                    message: 'Hello "World" with \n newlines and 中文',
+                    symbols: '!@#$%^&*()',
+                },
+                status: 'pending',
+                retryCount: 0,
+                maxRetries: 3,
+                createdTime: new Date().toISOString(),
+            };
+            await instance.getRedisClient()?.setEx(taskKey, 3600, JSON.stringify(specialTask));
+            const retrieved = await instance.testGetTask(taskId);
+            expect(retrieved).toEqual(specialTask);
+        });
+    });
+    describe('applyStatus 原子性测试', () => {
+        it('应该原子性地更新任务状态和队列位置', async () => {
+            const taskId = 'atomic-test-task';
+            const taskKey = `${queueKey}:task:${taskId}`;
+            const task = {
+                id: taskId,
+                data: { test: 'data' },
+                status: 'pending',
+                retryCount: 0,
+                maxRetries: 3,
+                createdTime: new Date().toISOString(),
+            };
+            // 初始化任务
+            await instance.getRedisClient()?.setEx(taskKey, 3600, JSON.stringify(task));
+            await instance.getRedisClient()?.rPush(`${queueKey}:pending`, taskId);
+            // 应用状态变更
+            await instance.testApplyStatus(taskId, 'pending', 'processing');
+            // 验证任务已从 pending 队列移除
+            const pendingList = await instance.getRedisClient()?.lRange(`${queueKey}:pending`, 0, -1);
+            expect(pendingList).not.toContain(taskId);
+            // 验证任务已添加到 processing 队列
+            const processingList = await instance.getRedisClient()?.lRange(`${queueKey}:processing`, 0, -1);
+            expect(processingList).toContain(taskId);
+            // 验证任务状态已更新
+            const updatedTask = await instance.testGetTask(taskId);
+            expect(updatedTask?.status).toBe('processing');
+        });
+        it('应该处理状态不变的情况', async () => {
+            const taskId = 'same-status-task';
+            const taskKey = `${queueKey}:task:${taskId}`;
+            const task = {
+                id: taskId,
+                data: { count: 1 },
+                status: 'processing',
+                retryCount: 0,
+                maxRetries: 3,
+                createdTime: new Date().toISOString(),
+            };
+            await instance.getRedisClient()?.setEx(taskKey, 3600, JSON.stringify(task));
+            await instance.getRedisClient()?.rPush(`${queueKey}:processing`, taskId);
+            // 应用相同状态的变更
+            await instance.testApplyStatus(taskId, 'processing', 'processing');
+            // 验证队列中只有一个任务
+            const processingList = await instance.getRedisClient()?.lRange(`${queueKey}:processing`, 0, -1);
+            expect(processingList?.length).toBe(1);
+        });
+        it('应该处理任务不存在的情况', async () => {
+            // 不应该抛出错误
+            await expect(instance.testApplyStatus('non-existent', 'pending', 'processing')).resolves.not.toThrow();
+        });
+        it('应该支持所有状态之间的转换', async () => {
+            const transitions = [
+                ['pending', 'processing'],
+                ['processing', 'completed'],
+                ['processing', 'failed'],
+                ['failed', 'pending'], // 重试
+            ];
+            for (const [from, to] of transitions) {
+                const taskId = `transition-${from}-${to}`;
+                const taskKey = `${queueKey}:task:${taskId}`;
+                const task = {
+                    id: taskId,
+                    data: { transition: `${from}-${to}` },
+                    status: from,
+                    retryCount: 0,
+                    maxRetries: 3,
+                    createdTime: new Date().toISOString(),
+                };
+                await instance.getRedisClient()?.setEx(taskKey, 3600, JSON.stringify(task));
+                await instance.getRedisClient()?.rPush(instance.testGetQueueByStatus(from), taskId);
+                await instance.testApplyStatus(taskId, from, to);
+                const updatedTask = await instance.testGetTask(taskId);
+                expect(updatedTask?.status).toBe(to);
+            }
+        });
+    });
+    describe('statistics 准确性测试', () => {
+        it('应该返回空队列的统计信息', async () => {
+            const stats = await instance.statistics();
+            expect(stats).toEqual({
+                pending: 0,
+                processing: 0,
+                completed: 0,
+                failed: 0,
+            });
+        });
+        it('应该准确统计大量任务', async () => {
+            const counts = {
+                pending: 100,
+                processing: 50,
+                completed: 200,
+                failed: 10,
+            };
+            // 添加任务到各个队列
+            for (const [status, count] of Object.entries(counts)) {
+                const queueName = instance.testGetQueueByStatus(status);
+                const taskIds = Array.from({ length: count }, (_, i) => `task-${status}-${i}`);
+                if (taskIds.length > 0) {
+                    await instance.getRedisClient()?.rPush(queueName, taskIds);
+                }
+            }
+            const stats = await instance.statistics();
+            expect(stats).toEqual(counts);
+        });
+        it('应该处理混合状态的任务', async () => {
+            // 添加一些任务到不同队列
+            await instance.getRedisClient()?.rPush(`${queueKey}:pending`, ['task1', 'task2', 'task3']);
+            await instance.getRedisClient()?.rPush(`${queueKey}:processing`, ['task4']);
+            await instance.getRedisClient()?.rPush(`${queueKey}:completed`, ['task5', 'task6']);
+            const stats = await instance.statistics();
+            expect(stats.pending).toBe(3);
+            expect(stats.processing).toBe(1);
+            expect(stats.completed).toBe(2);
+            expect(stats.failed).toBe(0);
+        });
+    });
+    describe('并发安全测试', () => {
+        it('应该支持并发的统计查询', async () => {
+            // 添加一些任务
+            await instance.getRedisClient()?.rPush(`${queueKey}:pending`, ['task1', 'task2']);
+            await instance.getRedisClient()?.rPush(`${queueKey}:processing`, ['task3']);
+            // 并发查询统计
+            const results = await Promise.all([
+                instance.statistics(),
+                instance.statistics(),
+                instance.statistics(),
+            ]);
+            // 所有结果应该一致
+            results.forEach(stats => {
+                expect(stats.pending).toBe(2);
+                expect(stats.processing).toBe(1);
+            });
+        });
+        it('应该支持并发的健康检查', async () => {
+            const results = await Promise.all([
+                instance.health(),
+                instance.health(),
+                instance.health(),
+            ]);
+            results.forEach(result => {
+                expect(result).toBe(true);
+            });
+        });
+        it('应该支持并发的任务查询', async () => {
+            const taskId = 'concurrent-task';
+            const taskKey = `${queueKey}:task:${taskId}`;
+            const task = {
+                id: taskId,
+                data: { concurrent: true },
+                status: 'pending',
+                retryCount: 0,
+                maxRetries: 3,
+                createdTime: new Date().toISOString(),
+            };
+            await instance.getRedisClient()?.setEx(taskKey, 3600, JSON.stringify(task));
+            const results = await Promise.all([
+                instance.testGetTask(taskId),
+                instance.testGetTask(taskId),
+                instance.testGetTask(taskId),
+            ]);
+            results.forEach(result => {
+                expect(result).toEqual(task);
+            });
+        });
+    });
+    describe('内存和性能测试', () => {
+        it('应该能处理带有大量数据的任务', async () => {
+            const taskId = 'large-data-task';
+            const taskKey = `${queueKey}:task:${taskId}`;
+            // 创建一个包含大量数据的任务
+            const largeData = {
+                items: Array.from({ length: 1000 }, (_, i) => ({
+                    id: i,
+                    name: `Item ${i}`,
+                    description: `This is a description for item ${i}`.repeat(10),
+                })),
+            };
+            const task = {
+                id: taskId,
+                data: largeData,
+                status: 'pending',
+                retryCount: 0,
+                maxRetries: 3,
+                createdTime: new Date().toISOString(),
+            };
+            await instance.getRedisClient()?.setEx(taskKey, 3600, JSON.stringify(task));
+            const retrieved = await instance.testGetTask(taskId);
+            expect(retrieved).toEqual(task);
+            expect((retrieved?.data).items.length).toBe(1000);
+        });
+        it('应该快速执行统计查询', async () => {
+            // 添加一些任务
+            const taskIds = Array.from({ length: 100 }, (_, i) => `perf-task-${i}`);
+            await instance.getRedisClient()?.rPush(`${queueKey}:pending`, taskIds);
+            const startTime = Date.now();
+            await instance.statistics();
+            const duration = Date.now() - startTime;
+            // 统计查询应该在100ms内完成
+            expect(duration).toBeLessThan(100);
+        });
+    });
+    describe('错误处理', () => {
+        // 跳过此测试,因为连接超时等待时间过长
+        it.skip('应该优雅处理连接失败', async () => {
+            const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            const badInstance = new TestRedisQueueCommon({
+                redisUrl: 'redis://invalid-host:9999',
+                queueKey: 'test-bad',
+            });
+            // 设置超时时间更短,并立即尝试连接
+            await expect(badInstance.connect()).rejects.toThrow();
+            // 清理
+            try {
+                badInstance.disconnect();
+            }
+            catch {
+                // 忽略断开连接的错误
+            }
+            errorSpy.mockRestore();
+        }, 10000); // 增加测试超时时间
+        it('应该在断开连接时优雅处理操作', async () => {
+            instance.disconnect();
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // 这些操作不应该抛出错误
+            const task = await instance.testGetTask('any-id');
+            expect(task).toBeNull();
+            const health = await instance.health();
+            expect(health).toBe(false);
+            const stats = await instance.statistics();
+            expect(stats).toEqual({
+                pending: 0,
+                processing: 0,
+                completed: 0,
+                failed: 0,
+            });
+        });
+    });
+    describe('队列键名一致性', () => {
+        it('所有队列键名应该使用正确的前缀', () => {
+            const config = instance.getConfig();
+            expect(config.pendingQueue).toContain(queueKey);
+            expect(config.processingQueue).toContain(queueKey);
+            expect(config.completedQueue).toContain(queueKey);
+            expect(config.failedQueue).toContain(queueKey);
+        });
+        it('应该为不同的 queueKey 生成不同的队列名', () => {
+            const instance1 = new TestRedisQueueCommon({
+                redisUrl: REDIS_URL,
+                queueKey: 'queue-one',
+            });
+            const instance2 = new TestRedisQueueCommon({
+                redisUrl: REDIS_URL,
+                queueKey: 'queue-two',
+            });
+            const config1 = instance1.getConfig();
+            const config2 = instance2.getConfig();
+            expect(config1.pendingQueue).not.toBe(config2.pendingQueue);
+            expect(config1.processingQueue).not.toBe(config2.processingQueue);
+        });
+    });
+});