@taicode/common-server 1.0.13 → 1.0.14

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

@@ -1,48 +1,43 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { RedisQueueProvider } from './redis-queue-provider';
-const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
-describe('RedisQueueProvider', () => {
+import { describe, it, expect, afterEach } from "vitest";
+import { RedisQueueProvider } from "./redis-queue-provider";
+import { clearQueue, getQueueTasks } from "./test-helpers";
+const REDIS_URL = process.env.REDIS_URL || "redis://localhost:6379";
+describe("RedisQueueProvider", () => {
     const providers = [];
     afterEach(async () => {
         for (const provider of providers) {
-            try {
-                await provider.clear();
-            }
-            catch (error) {
-                // 忽略清理错误
-            }
+            await clearQueue(provider);
             provider.disconnect();
         }
         providers.length = 0;
     });
     const createProvider = (options) => {
         const uniqueKey = `test:provider:${Date.now()}:${Math.random()}`;
-        const provider = new RedisQueueProvider({
+        const provider = new RedisQueueProvider(uniqueKey, {
             redisUrl: REDIS_URL,
-            queueKey: uniqueKey,
             ...options,
         });
         providers.push(provider);
         return provider;
     };
-    describe('连接管理', () => {
-        it('应该成功连接到 Redis', async () => {
+    describe("连接管理", () => {
+        it("应该成功连接到 Redis", async () => {
             const provider = createProvider();
             await provider.connect();
             const health = await provider.health();
             expect(health).toBe(true);
         });
     });
-    describe('任务入队', () => {
-        it('应该成功将任务推入队列', async () => {
+    describe("任务入队", () => {
+        it("应该成功将任务推入队列", async () => {
             const provider = createProvider();
             await provider.connect();
-            const taskId = await provider.enqueue({ foo: 'bar' });
+            const taskId = await provider.enqueue({ foo: "bar" });
             expect(taskId).toBeTruthy();
             const stats = await provider.statistics();
             expect(stats.pending).toBe(1);
         });
-        it('应该能够批量入队任务', async () => {
+        it("应该能够批量入队任务", async () => {
             const provider = createProvider();
             await provider.connect();
             const taskIds = await provider.enqueue([
@@ -54,34 +49,30 @@ describe('RedisQueueProvider', () => {
             const stats = await provider.statistics();
             expect(stats.pending).toBe(3);
         });
-        it('入队的任务应该包含正确的元数据', async () => {
+        it("入队的任务应该包含正确的元数据", async () => {
             const provider = createProvider();
             await provider.connect();
-            const taskId = await provider.enqueue({ test: 'data', number: 42 });
+            const taskId = await provider.enqueue({ test: "data", number: 42 });
             const task = await provider.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?.data).toEqual({ test: "data", number: 42 });
+            expect(task?.status).toBe("pending");
             expect(task?.retryCount).toBe(0);
         });
     });
-    describe('队列操作', () => {
-        it('应该正确返回队列统计信息', async () => {
+    describe("队列操作", () => {
+        it("应该正确返回队列统计信息", async () => {
             const provider = createProvider();
             await provider.connect();
-            await provider.enqueue([
-                { test: '1' },
-                { test: '2' },
-                { test: '3' },
-            ]);
+            await provider.enqueue([{ test: "1" }, { test: "2" }, { test: "3" }]);
             const stats = await provider.statistics();
             expect(stats.pending).toBe(3);
             expect(stats.processing).toBe(0);
             expect(stats.completed).toBe(0);
             expect(stats.failed).toBe(0);
         });
-        it('应该能够清空队列', async () => {
+        it("应该能够清空队列", async () => {
             const provider = createProvider();
             await provider.connect();
             await provider.enqueue([{ data: 1 }, { data: 2 }]);
@@ -89,23 +80,67 @@ describe('RedisQueueProvider', () => {
             const stats = await provider.statistics();
             expect(stats.pending).toBe(0);
         });
+        it("应该能够使用 getQueueTasks 获取特定状态的任务", async () => {
+            const provider = createProvider();
+            await provider.connect();
+            await provider.enqueue([
+                { name: "task1" },
+                { name: "task2" },
+                { name: "task3" },
+            ]);
+            const pendingTasks = await getQueueTasks(provider, "pending");
+            expect(pendingTasks).toHaveLength(3);
+            expect(pendingTasks.every(t => t.status === "pending")).toBe(true);
+            // 验证任务数据
+            const taskNames = pendingTasks.map(t => t.data.name);
+            expect(taskNames).toContain("task1");
+            expect(taskNames).toContain("task2");
+            expect(taskNames).toContain("task3");
+        });
     });
-    describe('幂等性', () => {
-        it('应该支持在 data 中指定 id 来实现幂等性', async () => {
+    describe("幂等性", () => {
+        it("应该支持在 data 中指定 id 来实现幂等性", async () => {
             const provider = createProvider();
             await provider.connect();
-            await provider.enqueue({ id: 'unique-1', value: 1 });
-            await provider.enqueue({ id: 'unique-1', value: 2 });
-            await provider.enqueue({ id: 'unique-2', value: 3 });
+            await provider.enqueue({ id: "unique-1", value: 1 });
+            await provider.enqueue({ id: "unique-1", value: 2 });
+            await provider.enqueue({ id: "unique-2", value: 3 });
             const stats = await provider.statistics();
             expect(stats.pending).toBe(2); // 只有 unique-1 和 unique-2
         });
+        it("应该拒绝非 string 类型的 id 并抛出 TypeError", async () => {
+            const provider = createProvider();
+            await provider.connect();
+            // 尝试传入数字类型的 id,应该抛出 TypeError
+            await expect(async () => {
+                await provider.enqueue({ id: 123, value: "test" });
+            }).rejects.toThrow(TypeError);
+            await expect(async () => {
+                await provider.enqueue({ id: 123, value: "test" });
+            }).rejects.toThrow(/must be a string/);
+            // 尝试传入布尔类型的 id,应该抛出 TypeError
+            await expect(async () => {
+                await provider.enqueue({ id: true, value: "test" });
+            }).rejects.toThrow(TypeError);
+            // 尝试传入对象类型的 id,应该抛出 TypeError
+            await expect(async () => {
+                await provider.enqueue({
+                    id: { nested: "value" },
+                    value: "test",
+                });
+            }).rejects.toThrow(TypeError);
+            // 字符串类型的 id 应该正常工作
+            await expect(provider.enqueue({ id: "123", value: "test" })).resolves.not.toThrow();
+            // 验证只有字符串 ID 的任务被入队
+            const stats = await provider.statistics();
+            expect(stats.pending).toBe(1);
+        });
     });
-    describe('延迟处理', () => {
-        it('应该支持延迟入队任务', async () => {
+    describe("延迟处理", () => {
+        it("应该支持延迟入队任务", async () => {
             const provider = createProvider({ processingDelay: 2000 });
             await provider.connect();
-            const taskId = await provider.enqueue({ test: true });
+            const taskId = (await provider.enqueue({ test: true }));
             const task = await provider.getTask(taskId);
             expect(task?.delayUntil).toBeDefined();
             expect(task?.delayUntil).toBeGreaterThan(Date.now());

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

@@ -0,0 +1,112 @@
+import type { RedisQueueBatchConsumer } from './redis-queue-batch-consumer';
+import { RedisQueueConsumer } from './redis-queue-consumer';
+import type { RedisQueueProvider } from './redis-queue-provider';
+import type { RedisQueueRegistry, Task } from './types';
+/**
+ * 测试辅助函数：立即派发任务到消费者
+ *
+ * 这个辅助函数提供了一个简洁的测试接口，让你能够立即派发任务到消费者，
+ * 而不需要等待定时轮询机制。这使得测试更加快速和可控。
+ *
+ * @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 declare function dispatchQueueTask<K extends keyof RedisQueueRegistry>(consumer: RedisQueueConsumer<K> | RedisQueueBatchConsumer<K>, taskIds: string[]): Promise<void>;
+/**
+ * 测试辅助函数：等待队列达到指定状态
+ *
+ * @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 declare function waitQueueCompletion<K extends keyof RedisQueueRegistry>(instance: RedisQueueProvider<K> | RedisQueueConsumer<K> | RedisQueueBatchConsumer<K>, predicate: (stats: {
+    pending: number;
+    processing: number;
+    completed: number;
+    failed: number;
+}) => boolean, options?: {
+    timeout?: number;
+    interval?: number;
+}): Promise<void>;
+/**
+ * 测试辅助函数：清空队列所有状态
+ *
+ * 用于测试前后的清理工作，支持 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 declare function clearQueue<K extends keyof RedisQueueRegistry>(instance: RedisQueueProvider<K> | RedisQueueConsumer<K> | RedisQueueBatchConsumer<K>): Promise<void>;
+/**
+ * 测试辅助函数：获取队列中的所有任务详情
+ *
+ * 用于测试验证，可以检查任务的完整状态
+ *
+ * @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 declare function getQueueTasks<K extends keyof RedisQueueRegistry>(provider: RedisQueueProvider<K>, status?: 'pending' | 'processing' | 'completed' | 'failed'): Promise<Task<RedisQueueRegistry[K]>[]>;
+//# sourceMappingURL=test-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../source/redis-queue/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,SAAS,MAAM,kBAAkB,EACxE,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,EAC5D,OAAO,EAAE,MAAM,EAAE,GAChB,OAAO,CAAC,IAAI,CAAC,CA+Ff;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CAAC,CAAC,SAAS,MAAM,kBAAkB,EAC1E,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,EACpF,SAAS,EAAE,CAAC,KAAK,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,EACzG,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GACpD,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,UAAU,CAAC,CAAC,SAAS,MAAM,kBAAkB,EACjE,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,GACnF,OAAO,CAAC,IAAI,CAAC,CAcf;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,aAAa,CAAC,CAAC,SAAS,MAAM,kBAAkB,EACpE,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,MAAM,CAAC,EAAE,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,QAAQ,GACzD,OAAO,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAmCxC"}

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

@@ -0,0 +1,242 @@
+import { RedisQueueConsumer } from './redis-queue-consumer';
+/**
+ * 测试辅助函数：立即派发任务到消费者
+ *
+ * 这个辅助函数提供了一个简洁的测试接口，让你能够立即派发任务到消费者，
+ * 而不需要等待定时轮询机制。这使得测试更加快速和可控。
+ *
+ * @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

@@ -0,0 +1,28 @@
+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' {
+    interface RedisQueueRegistry {
+        [key: `test:${string}`]: TestTaskData;
+    }
+}
+export {};
+//# sourceMappingURL=test-helpers.test.d.ts.map

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

@@ -0,0 +1 @@
+{"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,SAAS,CAAC;IACvB,UAAU,kBAAkB;QAC1B,CAAC,GAAG,EAAE,QAAQ,MAAM,EAAE,GAAG,YAAY,CAAA;KACtC;CACF"}