@taicode/common-server 3.7.5 → 3.7.7

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

@@ -1,242 +0,0 @@
-import { RedisQueueConsumer } from './redis-queue-consumer.js';
-/**
- * 测试辅助函数：立即派发任务到消费者
- *
- * 这个辅助函数提供了一个简洁的测试接口，让你能够立即派发任务到消费者，
- * 而不需要等待定时轮询机制。这使得测试更加快速和可控。
- *
- * @param consumer RedisQueueConsumer 或 RedisQueueBatchConsumer 实例
- * @param taskIds 要派发的任务 ID 列表
- * @returns Promise，等待所有任务处理完成
- *
- * @example
- * ```ts
- * import { dispatchQueueTask } from '@taicode/common-server/redis-queue/test-helpers'
- * import { RedisQueueProvider, RedisQueueConsumer } from '@taicode/common-server/redis-queue'
- *
- * describe('My Queue Tests', () => {
- *   it('should process tasks', async () => {
- *     const provider = new RedisQueueProvider({ ... })
- *     const consumer = new RedisQueueConsumer({ ... })
- *
- *     await provider.connect()
- *     await consumer.connect()
- *
- *     // 添加任务
- *     const taskId = await provider.enqueue({ data: 'test' })
- *
- *     // 立即派发任务进行测试
- *     await dispatchQueueTask(consumer, [taskId as string])
- *
- *     // 验证结果
- *     const stats = await consumer.statistics()
- *     expect(stats.completed).toBe(1)
- *   })
- * })
- * ```
- */
-export async function dispatchQueueTask(consumer, taskIds) {
-    if (taskIds.length === 0) {
-        return;
-    }
-    // @ts-ignore - 访问 protected 属性用于测试
-    const redis = consumer.redis;
-    // @ts-ignore
-    const queueKey = consumer.queueKey;
-    // @ts-ignore
-    const pendingQueue = consumer.pendingQueue;
-    // @ts-ignore
-    const processingQueue = consumer.processingQueue;
-    if (!redis || !redis.isOpen) {
-        throw new Error('Redis client is not connected');
-    }
-    // 使用 Lua 脚本将指定的任务从 pending 移到 processing 队列
-    const moveTasksScript = `
-    local pendingQueue = KEYS[1]
-    local processingQueue = KEYS[2]
-    local moved = 0
-    
-    for i = 3, #KEYS do
-      local taskId = KEYS[i]
-      -- 从 pending 队列移除
-      local removed = redis.call('LREM', pendingQueue, 1, taskId)
-      if (removed > 0) then
-        -- 添加到 processing 队列
-        redis.call('RPUSH', processingQueue, taskId)
-        moved = moved + 1
-      end
-    end
-    
-    return moved
-  `;
-    // 持续处理直到所有任务完成或失败
-    let remainingTasks = [...taskIds];
-    let maxAttempts = 100; // 防止无限循环
-    let attempts = 0;
-    while (remainingTasks.length > 0 && attempts < maxAttempts) {
-        attempts++;
-        // 移动任务到 processing 队列
-        await redis.eval(moveTasksScript, {
-            keys: [pendingQueue, processingQueue, ...remainingTasks],
-            arguments: [],
-        });
-        // 处理任务
-        if (consumer instanceof RedisQueueConsumer) {
-            // RedisQueueConsumer: 逐个处理任务
-            const promises = remainingTasks.map(taskId => 
-            // @ts-ignore
-            consumer.processTask(taskId).catch(() => {
-                // 忽略错误,让 consumer 内部处理
-            }));
-            await Promise.all(promises);
-        }
-        else {
-            // RedisQueueBatchConsumer: 按照 consumer 的 batchSize 分批处理任务
-            // @ts-ignore
-            const batchConsumer = consumer;
-            const batchSize = batchConsumer.config?.batchSize || 10;
-            // 分批处理任务
-            for (let i = 0; i < remainingTasks.length; i += batchSize) {
-                const batch = remainingTasks.slice(i, i + batchSize);
-                try {
-                    // @ts-ignore
-                    await batchConsumer.processBatch(batch);
-                }
-                catch (error) {
-                    // 批次处理失败是正常的,consumer 会处理重试逻辑
-                }
-            }
-        }
-        // 等待一小段时间让重试任务被放回 pending 队列
-        await new Promise(resolve => setTimeout(resolve, 10));
-        // 检查还有哪些任务在 pending 队列中(需要重试)
-        const stillPending = [];
-        for (const taskId of remainingTasks) {
-            // @ts-ignore
-            const task = await consumer.getTask(taskId);
-            if (task && task.status === 'pending') {
-                stillPending.push(taskId);
-            }
-        }
-        remainingTasks = stillPending;
-    }
-}
-/**
- * 测试辅助函数：等待队列达到指定状态
- *
- * @param instance Provider 或 Consumer 实例
- * @param predicate 状态断言函数
- * @param options 配置选项
- * @returns Promise，在条件满足时 resolve
- *
- * @example
- * ```ts
- * // 使用 consumer 等待所有任务完成
- * await waitQueueCompletion(consumer, stats => stats.pending === 0 && stats.processing === 0)
- *
- * // 使用 provider 等待至少完成 10 个任务
- * await waitQueueCompletion(provider, stats => stats.completed >= 10, { timeout: 5000 })
- * ```
- */
-export async function waitQueueCompletion(instance, predicate, options = {}) {
-    const timeout = options.timeout ?? 10000; // 默认 10 秒超时
-    const interval = options.interval ?? 100; // 默认 100ms 检查间隔
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeout) {
-        const stats = await instance.statistics();
-        if (predicate(stats)) {
-            return;
-        }
-        await new Promise(resolve => setTimeout(resolve, interval));
-    }
-    const finalStats = await instance.statistics();
-    throw new Error(`Queue state timeout after ${timeout}ms. Final state: ${JSON.stringify(finalStats)}`);
-}
-/**
- * 测试辅助函数：清空队列所有状态
- *
- * 用于测试前后的清理工作，支持 Provider 或 Consumer 实例
- *
- * @param instance Provider 或 Consumer 实例
- * @returns Promise
- *
- * @example
- * ```ts
- * // 使用 consumer 清理
- * afterEach(async () => {
- *   await clearQueue(consumer)
- *   consumer.disconnect()
- * })
- *
- * // 使用 provider 清理
- * afterEach(async () => {
- *   await clearQueue(provider)
- *   provider.disconnect()
- * })
- * ```
- */
-export async function clearQueue(instance) {
-    // 访问 protected 属性需要类型断言
-    const redis = instance.redis;
-    const queueKey = instance.queueKey;
-    if (!redis || !redis.isOpen) {
-        return;
-    }
-    // 删除所有队列相关的键
-    const keys = await redis.keys(`${queueKey}:*`);
-    if (keys.length > 0) {
-        await redis.del(keys);
-    }
-}
-/**
- * 测试辅助函数：获取队列中的所有任务详情
- *
- * 用于测试验证，可以检查任务的完整状态
- *
- * @param provider Provider 实例
- * @param status 可选，筛选特定状态的任务
- * @returns 任务列表
- *
- * @example
- * ```typescript
- * // 获取所有失败的任务
- * const failedTasks = await getQueueTasks(provider, 'failed')
- * expect(failedTasks).toHaveLength(3)
- *
- * // 验证任务数据
- * expect(failedTasks[0].data).toMatchObject({ id: 123 })
- * ```
- */
-export async function getQueueTasks(provider, status) {
-    // @ts-ignore
-    const redis = provider.redis;
-    // @ts-ignore
-    const queueKey = provider.queueKey;
-    if (!redis || !redis.isOpen) {
-        return [];
-    }
-    const queueName = status ? `${queueKey}:${status}` : null;
-    const tasks = [];
-    if (queueName) {
-        // 获取特定状态队列中的所有任务 ID
-        const taskIds = await redis.lRange(queueName, 0, -1);
-        for (const taskId of taskIds) {
-            const taskKey = `${queueKey}:task:${taskId}`;
-            const taskData = await redis.get(taskKey);
-            if (taskData) {
-                tasks.push(JSON.parse(taskData));
-            }
-        }
-    }
-    else {
-        // 获取所有任务
-        const taskKeys = await redis.keys(`${queueKey}:task:*`);
-        for (const taskKey of taskKeys) {
-            const taskData = await redis.get(taskKey);
-            if (taskData) {
-                tasks.push(JSON.parse(taskData));
-            }
-        }
-    }
-    return tasks;
-}

package/output/redis-queue/test-helpers.test.d.ts

@@ -1,28 +0,0 @@
-type TestTaskData = {
-    id?: string;
-    message?: string;
-    value?: string | number;
-    name?: string;
-    test?: string | boolean;
-    shouldFail?: boolean;
-    order?: number;
-    taskId?: number;
-    index?: number;
-    step?: number;
-    real?: boolean;
-    nested?: {
-        value: number;
-    };
-    example?: string;
-    payload?: string;
-    data?: any;
-    foo?: string;
-    number?: number;
-};
-declare module './types.js' {
-    interface RedisQueueRegistry {
-        [key: `test:${string}`]: TestTaskData;
-    }
-}
-export {};
-//# sourceMappingURL=test-helpers.test.d.ts.map

package/output/redis-queue/test-helpers.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-helpers.test.d.ts","sourceRoot":"","sources":["../../source/redis-queue/test-helpers.test.ts"],"names":[],"mappings":"AAcA,KAAK,YAAY,GAAG;IAClB,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IACvB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,GAAG,CAAA;IACV,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAGD,OAAO,QAAQ,YAAY,CAAC;IAC1B,UAAU,kBAAkB;QAC1B,CAAC,GAAG,EAAE,QAAQ,MAAM,EAAE,GAAG,YAAY,CAAA;KACtC;CACF"}