@taicode/common-base 1.7.2 → 1.7.3

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

@@ -0,0 +1,1033 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { FlowQueue } from './flow-queue';
+describe('FlowQueue', () => {
+    let flowQueue;
+    let mockProcessor;
+    beforeEach(() => {
+        // 重置 mock processor
+        mockProcessor = vi.fn();
+        flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+    });
+    describe('基本功能', () => {
+        it('应该正确初始化', () => {
+            expect(flowQueue.successOutputs.size).toBe(0);
+            expect(flowQueue.erroredOutputs.size).toBe(0);
+            expect(flowQueue['pendingInputs'].length).toBe(0);
+            expect(flowQueue['processedInputs'].length).toBe(0);
+        });
+        it('应该接受输入并开始处理', async () => {
+            const testInput = { id: 1, data: 'test' };
+            const expectedOutput = { id: 1, result: 'processed', timestamp: Date.now() };
+            mockProcessor = vi.fn().mockResolvedValue(expectedOutput);
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            flowQueue.input(testInput);
+            // 等待异步处理完成
+            await new Promise(resolve => setTimeout(resolve, 50));
+            expect(mockProcessor).toHaveBeenCalledWith(testInput);
+            expect(flowQueue.successOutputs.get(testInput)).toEqual(expectedOutput);
+            expect(flowQueue['processedInputs']).toContain(testInput);
+            expect(flowQueue['pendingInputs']).not.toContain(testInput);
+        });
+        it('应该能处理多个输入', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' }
+            ];
+            mockProcessor = vi.fn().mockImplementation(async (input) => ({
+                id: input.id,
+                result: `processed_${input.data}`,
+                timestamp: Date.now()
+            }));
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            flowQueue.input(...inputs);
+            // 等待所有异步处理完成
+            await new Promise(resolve => setTimeout(resolve, 100));
+            expect(mockProcessor).toHaveBeenCalledTimes(3);
+            expect(flowQueue['processedInputs'].length).toBe(3);
+            expect(flowQueue['pendingInputs'].length).toBe(0);
+            inputs.forEach(input => {
+                const output = flowQueue.successOutputs.get(input);
+                expect(output.id).toBe(input.id);
+                expect(output.result).toBe(`processed_${input.data}`);
+            });
+        });
+    });
+    describe('错误处理', () => {
+        it('应该在处理失败时记录错误', async () => {
+            const testInput = { id: 1, data: 'test' };
+            const errorMessage = 'Processing failed';
+            mockProcessor = vi.fn().mockRejectedValue(new Error(errorMessage));
+            flowQueue = new FlowQueue({ retry: { maxRetries: 0 } }, mockProcessor); // 不重试
+            flowQueue.input(testInput);
+            await new Promise(resolve => setTimeout(resolve, 50));
+            const errorResult = flowQueue.erroredOutputs.get(testInput);
+            expect(errorResult).toBeInstanceOf(Error);
+            expect(errorResult.message).toBe(errorMessage);
+            expect(flowQueue['processedInputs']).toContain(testInput);
+        });
+        it('应该处理非 Error 类型的异常', async () => {
+            const testInput = { id: 1, data: 'test' };
+            const errorMessage = 'String error';
+            mockProcessor = vi.fn().mockRejectedValue(errorMessage);
+            flowQueue = new FlowQueue({ retry: { maxRetries: 0 } }, mockProcessor);
+            flowQueue.input(testInput);
+            await new Promise(resolve => setTimeout(resolve, 50));
+            const errorResult = flowQueue.erroredOutputs.get(testInput);
+            expect(errorResult).toBe(errorMessage);
+        });
+    });
+    describe('重试机制', () => {
+        it('应该在失败时重试', async () => {
+            const testInput = { id: 1, data: 'test' };
+            const successOutput = { id: 1, result: 'success', timestamp: Date.now() };
+            // 前两次调用失败，第三次成功
+            mockProcessor = vi.fn()
+                .mockRejectedValueOnce(new Error('First failure'))
+                .mockRejectedValueOnce(new Error('Second failure'))
+                .mockResolvedValueOnce(successOutput);
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            flowQueue.input(testInput);
+            await new Promise(resolve => setTimeout(resolve, 100));
+            expect(mockProcessor).toHaveBeenCalledTimes(3);
+            expect(flowQueue.successOutputs.get(testInput)).toEqual(successOutput);
+            expect(flowQueue['processedInputs']).toContain(testInput);
+        });
+        it('应该在超过最大重试次数后停止重试', async () => {
+            const testInput = { id: 1, data: 'test' };
+            const errorMessage = 'Persistent failure';
+            mockProcessor = vi.fn().mockRejectedValue(new Error(errorMessage));
+            flowQueue = new FlowQueue({ retry: { maxRetries: 2 } }, mockProcessor);
+            flowQueue.input(testInput);
+            await new Promise(resolve => setTimeout(resolve, 100));
+            // 应该调用 3 次（初始 + 2 次重试）
+            expect(mockProcessor).toHaveBeenCalledTimes(3);
+            const errorResult = flowQueue.erroredOutputs.get(testInput);
+            expect(errorResult).toBeInstanceOf(Error);
+            expect(errorResult.message).toBe(errorMessage);
+            expect(flowQueue['processedInputs']).toContain(testInput);
+        });
+        it('应该使用默认的最大重试次数', async () => {
+            const testInput = { id: 1, data: 'test' };
+            mockProcessor = vi.fn().mockRejectedValue(new Error('Failure'));
+            flowQueue = new FlowQueue({}, mockProcessor); // 不指定 maxRetries
+            flowQueue.input(testInput);
+            await new Promise(resolve => setTimeout(resolve, 150));
+            // 应该调用 4 次（初始 + 3 次重试，默认值为 3）
+            expect(mockProcessor).toHaveBeenCalledTimes(4);
+        });
+    });
+    describe('回调机制', () => {
+        it('应该在成功处理后调用 onGenerate 回调', async () => {
+            const testInput = { id: 1, data: 'test' };
+            const expectedOutput = { id: 1, result: 'success', timestamp: Date.now() };
+            const callback = vi.fn();
+            mockProcessor = vi.fn().mockResolvedValue(expectedOutput);
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            const unsubscribe = flowQueue.onGenerate(callback);
+            flowQueue.input(testInput);
+            await new Promise(resolve => setTimeout(resolve, 50));
+            expect(callback).toHaveBeenCalledWith(expectedOutput);
+            expect(callback).toHaveBeenCalledTimes(1);
+            // 测试取消订阅
+            unsubscribe();
+            const anotherInput = { id: 2, data: 'test2' };
+            flowQueue.input(anotherInput);
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // 回调不应该再被调用
+            expect(callback).toHaveBeenCalledTimes(1);
+        });
+        it('应该支持多个回调', async () => {
+            const testInput = { id: 1, data: 'test' };
+            const expectedOutput = { id: 1, result: 'success', timestamp: Date.now() };
+            const callback1 = vi.fn();
+            const callback2 = vi.fn();
+            mockProcessor = vi.fn().mockResolvedValue(expectedOutput);
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            flowQueue.onGenerate(callback1);
+            flowQueue.onGenerate(callback2);
+            flowQueue.input(testInput);
+            await new Promise(resolve => setTimeout(resolve, 50));
+            expect(callback1).toHaveBeenCalledWith(expectedOutput);
+            expect(callback2).toHaveBeenCalledWith(expectedOutput);
+        });
+        it('应该处理回调中的错误', async () => {
+            const testInput = { id: 1, data: 'test' };
+            const expectedOutput = { id: 1, result: 'success', timestamp: Date.now() };
+            const faultyCallback = vi.fn().mockImplementation(() => {
+                throw new Error('Callback error');
+            });
+            const normalCallback = vi.fn();
+            // Mock console.error 来验证错误被正确记录
+            const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            mockProcessor = vi.fn().mockResolvedValue(expectedOutput);
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            flowQueue.onGenerate(faultyCallback);
+            flowQueue.onGenerate(normalCallback);
+            flowQueue.input(testInput);
+            await new Promise(resolve => setTimeout(resolve, 50));
+            expect(faultyCallback).toHaveBeenCalled();
+            expect(normalCallback).toHaveBeenCalledWith(expectedOutput);
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Error in onGenerate callback:', expect.any(Error));
+            consoleErrorSpy.mockRestore();
+        });
+        it('失败的处理不应该触发回调', async () => {
+            const testInput = { id: 1, data: 'test' };
+            const callback = vi.fn();
+            mockProcessor = vi.fn().mockRejectedValue(new Error('Failure'));
+            flowQueue = new FlowQueue({ retry: { maxRetries: 0 } }, mockProcessor);
+            flowQueue.onGenerate(callback);
+            flowQueue.input(testInput);
+            await new Promise(resolve => setTimeout(resolve, 50));
+            expect(callback).not.toHaveBeenCalled();
+        });
+    });
+    describe('并发处理', () => {
+        it('应该防止并发处理', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' }
+            ];
+            // 模拟较慢的处理器
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                await new Promise(resolve => setTimeout(resolve, 30));
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            // 快速添加两个输入
+            flowQueue.input(inputs[0]);
+            flowQueue.input(inputs[1]);
+            await new Promise(resolve => setTimeout(resolve, 100));
+            // 应该按顺序处理
+            expect(mockProcessor).toHaveBeenCalledTimes(2);
+            expect(flowQueue['processedInputs'].length).toBe(2);
+        });
+    });
+    describe('边界情况', () => {
+        it('应该处理空输入', () => {
+            flowQueue.input();
+            expect(flowQueue['pendingInputs'].length).toBe(0);
+        });
+        it('应该处理 processor 返回 undefined 的情况', async () => {
+            const testInput = { id: 1, data: 'test' };
+            mockProcessor = vi.fn().mockResolvedValue(undefined);
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            flowQueue.input(testInput);
+            await new Promise(resolve => setTimeout(resolve, 50));
+            expect(flowQueue.successOutputs.get(testInput)).toBeUndefined();
+            expect(flowQueue['processedInputs']).toContain(testInput);
+        });
+        it('应该正确处理输入关闭后的新输入', () => {
+            const testInput = { id: 1, data: 'test' };
+            flowQueue.closeInput();
+            flowQueue.input(testInput);
+            // 输入关闭后新添加的输入应该被忽略
+            expect(flowQueue['pendingInputs'].length).toBe(0);
+        });
+        it('应该处理 processor 抛出非标准错误的情况', async () => {
+            const testInput = { id: 1, data: 'test' };
+            // 抛出 null 错误
+            mockProcessor = vi.fn().mockRejectedValue(null);
+            flowQueue = new FlowQueue({ retry: { maxRetries: 0 } }, mockProcessor);
+            flowQueue.input(testInput);
+            await new Promise(resolve => setTimeout(resolve, 50));
+            const errorResult = flowQueue.erroredOutputs.get(testInput);
+            expect(errorResult).toBe(null);
+        });
+        it('应该处理 processor 抛出 undefined 错误的情况', async () => {
+            const testInput = { id: 1, data: 'test' };
+            // 抛出 undefined 错误
+            mockProcessor = vi.fn().mockRejectedValue(undefined);
+            flowQueue = new FlowQueue({ retry: { maxRetries: 0 } }, mockProcessor);
+            flowQueue.input(testInput);
+            await new Promise(resolve => setTimeout(resolve, 50));
+            const errorResult = flowQueue.erroredOutputs.get(testInput);
+            expect(errorResult).toBe(undefined);
+        });
+    });
+    describe('任务间延迟配置', () => {
+        it('应该在任务间应用基础延迟', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' }
+            ];
+            const processingTimes = [];
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                processingTimes.push(Date.now());
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            flowQueue = new FlowQueue({
+                delay: { base: 100 } // 100ms 延迟
+            }, mockProcessor);
+            const startTime = Date.now();
+            flowQueue.input(...inputs);
+            await new Promise(resolve => setTimeout(resolve, 300));
+            expect(mockProcessor).toHaveBeenCalledTimes(2);
+            // 验证任务间确实有延迟
+            if (processingTimes.length >= 2) {
+                const delayBetweenTasks = processingTimes[1] - processingTimes[0];
+                expect(delayBetweenTasks).toBeGreaterThanOrEqual(90); // 允许一些时序误差
+            }
+        });
+        it('应该支持自定义延迟函数', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' }
+            ];
+            let customDelayCallCount = 0;
+            const customDelayFn = vi.fn(() => {
+                customDelayCallCount++;
+                return customDelayCallCount * 50; // 递增延迟
+            });
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            flowQueue = new FlowQueue({
+                delay: { customDelayFn }
+            }, mockProcessor);
+            flowQueue.input(...inputs);
+            await new Promise(resolve => setTimeout(resolve, 200));
+            expect(customDelayFn).toHaveBeenCalled();
+            expect(mockProcessor).toHaveBeenCalledTimes(2);
+        });
+        it('应该支持延迟抖动', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' }
+            ];
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            flowQueue = new FlowQueue({
+                delay: {
+                    base: 100,
+                    jitter: true,
+                    jitterRange: 0.5 // 50% 抖动范围
+                }
+            }, mockProcessor);
+            flowQueue.input(...inputs);
+            await new Promise(resolve => setTimeout(resolve, 500));
+            expect(mockProcessor).toHaveBeenCalledTimes(3);
+            // 只验证抖动功能被启用，而不验证具体的时间差
+            // 因为时间差可能因为系统负载等因素而变化
+            expect(flowQueue.successOutputs.size).toBe(3);
+        });
+    });
+    describe('retry 方法', () => {
+        it('retry() 应该返回正确的重试数量', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' }
+            ];
+            mockProcessor = vi.fn().mockRejectedValue(new Error('处理失败'));
+            flowQueue = new FlowQueue({ retry: { maxRetries: 0 } }, mockProcessor);
+            flowQueue.input(...inputs);
+            await new Promise(resolve => setTimeout(resolve, 100));
+            expect(flowQueue.erroredOutputs.size).toBe(2);
+            const retryCount = flowQueue.retry();
+            expect(retryCount).toBe(2);
+        });
+        it('retry() 在没有失败输入时应该返回 0', () => {
+            const retryCount = flowQueue.retry();
+            expect(retryCount).toBe(0);
+        });
+        it('retry() 应该清除重试计数', async () => {
+            const testInput = { id: 1, data: 'test' };
+            // 让处理失败以触发重试计数，但要确保达到最大重试次数
+            mockProcessor = vi.fn().mockRejectedValue(new Error('处理失败'));
+            flowQueue = new FlowQueue({ retry: { maxRetries: 2 } }, mockProcessor);
+            flowQueue.input(testInput);
+            // 等待足够长的时间，确保重试过程完成
+            await new Promise(resolve => setTimeout(resolve, 200));
+            // 验证处理失败并且有重试计数
+            expect(flowQueue.erroredOutputs.has(testInput)).toBe(true);
+            // 执行 retry() 应该清除重试计数和错误记录
+            flowQueue.retry();
+            expect(flowQueue.erroredOutputs.has(testInput)).toBe(false);
+            expect(flowQueue['retryCount'].has(testInput)).toBe(false);
+        });
+        it('retry() 应该保持输入关闭状态', async () => {
+            const testInput = { id: 1, data: 'test' };
+            mockProcessor = vi.fn().mockRejectedValue(new Error('处理失败'));
+            flowQueue = new FlowQueue({ retry: { maxRetries: 0 } }, mockProcessor);
+            flowQueue.input(testInput);
+            flowQueue.closeInput();
+            await new Promise(resolve => setTimeout(resolve, 100));
+            expect(flowQueue['isInputClosed']).toBe(true);
+            flowQueue.retry();
+            expect(flowQueue['isInputClosed']).toBe(true); // 应该保持关闭状态
+        });
+    });
+    describe('重试策略', () => {
+        describe('立即重试 (immediate)', () => {
+            it('应该立即重试不延迟', async () => {
+                const testInput = { id: 1, data: 'test' };
+                const successOutput = { id: 1, result: 'success', timestamp: Date.now() };
+                mockProcessor = vi.fn()
+                    .mockRejectedValueOnce(new Error('First failure'))
+                    .mockResolvedValueOnce(successOutput);
+                const retryRule = { strategy: 'immediate' };
+                flowQueue = new FlowQueue({ retry: { maxRetries: 2, ...retryRule } }, mockProcessor);
+                flowQueue.input(testInput);
+                // 等待异步处理完成
+                await new Promise(resolve => setTimeout(resolve, 50));
+                expect(mockProcessor).toHaveBeenCalledTimes(2);
+                expect(flowQueue.successOutputs.get(testInput)).toEqual(successOutput);
+            });
+        });
+        describe('延迟计算', () => {
+            it('固定延迟应该返回基础延迟', () => {
+                const retryRule = {
+                    strategy: 'fixed',
+                    baseDelay: 1000
+                };
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3, ...retryRule } }, mockProcessor);
+                expect(flowQueue['calculateRetryDelay'](0)).toBe(1000);
+                expect(flowQueue['calculateRetryDelay'](1)).toBe(1000);
+                expect(flowQueue['calculateRetryDelay'](2)).toBe(1000);
+            });
+            it('指数退避应该返回递增延迟', () => {
+                const retryRule = {
+                    strategy: 'exponential',
+                    baseDelay: 1000,
+                    multiplier: 2
+                };
+                flowQueue = new FlowQueue({ retry: { maxRetries: 5, ...retryRule } }, mockProcessor);
+                expect(flowQueue['calculateRetryDelay'](0)).toBe(1000); // 1000 * 2^0 = 1000
+                expect(flowQueue['calculateRetryDelay'](1)).toBe(2000); // 1000 * 2^1 = 2000
+                expect(flowQueue['calculateRetryDelay'](2)).toBe(4000); // 1000 * 2^2 = 4000
+                expect(flowQueue['calculateRetryDelay'](3)).toBe(8000); // 1000 * 2^3 = 8000
+            });
+            it('指数退避应该限制最大延迟时间', () => {
+                const retryRule = {
+                    strategy: 'exponential',
+                    baseDelay: 1000,
+                    multiplier: 2,
+                    maxDelay: 3000 // 限制最大延迟
+                };
+                flowQueue = new FlowQueue({ retry: { maxRetries: 5, ...retryRule } }, mockProcessor);
+                expect(flowQueue['calculateRetryDelay'](0)).toBe(1000); // 1000 * 2^0 = 1000
+                expect(flowQueue['calculateRetryDelay'](1)).toBe(2000); // 1000 * 2^1 = 2000
+                expect(flowQueue['calculateRetryDelay'](2)).toBe(3000); // min(1000 * 2^2, 3000) = 3000
+                expect(flowQueue['calculateRetryDelay'](3)).toBe(3000); // min(1000 * 2^3, 3000) = 3000
+            });
+            it('线性增长应该返回线性递增延迟', () => {
+                const retryRule = {
+                    strategy: 'linear',
+                    baseDelay: 1000
+                };
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3, ...retryRule } }, mockProcessor);
+                expect(flowQueue['calculateRetryDelay'](0)).toBe(1000); // 1000 * (0 + 1) = 1000
+                expect(flowQueue['calculateRetryDelay'](1)).toBe(2000); // 1000 * (1 + 1) = 2000
+                expect(flowQueue['calculateRetryDelay'](2)).toBe(3000); // 1000 * (2 + 1) = 3000
+            });
+            it('自定义策略应该使用自定义延迟函数', () => {
+                const customDelayFn = vi.fn()
+                    .mockReturnValueOnce(500)
+                    .mockReturnValueOnce(1500)
+                    .mockReturnValueOnce(2500);
+                const retryRule = {
+                    strategy: 'custom',
+                    baseDelay: 1000,
+                    customDelayFn
+                };
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3, ...retryRule } }, mockProcessor);
+                expect(flowQueue['calculateRetryDelay'](0)).toBe(500);
+                expect(flowQueue['calculateRetryDelay'](1)).toBe(1500);
+                expect(flowQueue['calculateRetryDelay'](2)).toBe(2500);
+                expect(customDelayFn).toHaveBeenCalledWith(0, 1000);
+                expect(customDelayFn).toHaveBeenCalledWith(1, 1000);
+                expect(customDelayFn).toHaveBeenCalledWith(2, 1000);
+            });
+            it('自定义策略应该处理错误的函数', () => {
+                const customDelayFn = vi.fn().mockReturnValue(500);
+                const retryRule = {
+                    strategy: 'custom',
+                    baseDelay: 1000,
+                    customDelayFn
+                };
+                flowQueue = new FlowQueue({ retry: { maxRetries: 2, ...retryRule } }, mockProcessor);
+                expect(flowQueue['calculateRetryDelay'](0)).toBe(500);
+                expect(flowQueue['calculateRetryDelay'](1)).toBe(500);
+                expect(customDelayFn).toHaveBeenCalledWith(0, 1000);
+                expect(customDelayFn).toHaveBeenCalledWith(1, 1000);
+            });
+            it('应该为延迟添加随机抖动', () => {
+                const retryRule = {
+                    strategy: 'fixed',
+                    baseDelay: 1000,
+                    jitter: true
+                };
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3, ...retryRule } }, mockProcessor);
+                // 多次计算延迟，验证有抖动
+                const delays = Array.from({ length: 10 }, () => flowQueue['calculateRetryDelay'](0));
+                // 所有延迟应该在合理范围内（900-1100ms）
+                delays.forEach(delay => {
+                    expect(delay).toBeGreaterThanOrEqual(900);
+                    expect(delay).toBeLessThanOrEqual(1100);
+                });
+                // 应该有一定的变化（不是所有值都相同）
+                const uniqueDelays = new Set(delays);
+                expect(uniqueDelays.size).toBeGreaterThan(1);
+            });
+            it('不应该为零延迟添加抖动', () => {
+                const retryRule = {
+                    strategy: 'immediate',
+                    jitter: true
+                };
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3, ...retryRule } }, mockProcessor);
+                const delay = flowQueue['calculateRetryDelay'](0);
+                expect(delay).toBe(0);
+            });
+        });
+        describe('集成测试', () => {
+            it('应该使用固定延迟策略进行重试', async () => {
+                const testInput = { id: 1, data: 'test' };
+                let attemptCount = 0;
+                mockProcessor = vi.fn().mockImplementation(async () => {
+                    attemptCount++;
+                    if (attemptCount <= 2) {
+                        throw new Error(`Attempt ${attemptCount} failed`);
+                    }
+                    return { id: 1, result: 'success', timestamp: Date.now() };
+                });
+                const retryRule = {
+                    strategy: 'fixed',
+                    baseDelay: 100 // 使用较短的延迟以加快测试
+                };
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3, ...retryRule } }, mockProcessor);
+                flowQueue.input(testInput);
+                // 等待足够时间让所有重试完成
+                await new Promise(resolve => setTimeout(resolve, 500));
+                expect(mockProcessor).toHaveBeenCalledTimes(3);
+                const result = flowQueue.successOutputs.get(testInput);
+                expect(result.result).toBe('success');
+            });
+        });
+    });
+    describe('生命周期管理', () => {
+        describe('closeInput 方法', () => {
+            it('应该标记输入为关闭状态', () => {
+                const testInput = { id: 1, data: 'test' };
+                flowQueue.input(testInput);
+                expect(flowQueue['isInputClosed']).toBe(false);
+                flowQueue.closeInput();
+                expect(flowQueue['isInputClosed']).toBe(true);
+            });
+            it('在没有待处理输入时应该立即解决完成 Promise', async () => {
+                flowQueue.closeInput();
+                const completionPromise = flowQueue.awaitCompletion();
+                await expect(completionPromise).resolves.toBeUndefined();
+            });
+            it('在有待处理输入时应该等待处理完成', async () => {
+                const testInput = { id: 1, data: 'test' };
+                const expectedOutput = { id: 1, result: 'success', timestamp: Date.now() };
+                mockProcessor = vi.fn().mockImplementation(async () => {
+                    await new Promise(resolve => setTimeout(resolve, 50));
+                    return expectedOutput;
+                });
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+                flowQueue.input(testInput);
+                flowQueue.closeInput();
+                const completionPromise = flowQueue.awaitCompletion();
+                await expect(completionPromise).resolves.toBeUndefined();
+                expect(flowQueue.successOutputs.get(testInput)).toEqual(expectedOutput);
+            });
+        });
+        describe('awaitCompletion 方法', () => {
+            it('在已完成状态下应该立即返回 resolved Promise', async () => {
+                flowQueue.closeInput();
+                const promise = flowQueue.awaitCompletion();
+                await expect(promise).resolves.toBeUndefined();
+            });
+            it('多次调用应该返回同一个 Promise', () => {
+                const testInput = { id: 1, data: 'test' };
+                flowQueue.input(testInput);
+                flowQueue.closeInput();
+                const promise1 = flowQueue.awaitCompletion();
+                const promise2 = flowQueue.awaitCompletion();
+                expect(promise1).toBe(promise2);
+            });
+            it('应该等待所有输入处理完成', async () => {
+                const inputs = [
+                    { id: 1, data: 'test1' },
+                    { id: 2, data: 'test2' },
+                    { id: 3, data: 'test3' }
+                ];
+                mockProcessor = vi.fn().mockImplementation(async (input) => {
+                    await new Promise(resolve => setTimeout(resolve, 30));
+                    return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+                });
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+                flowQueue.input(...inputs);
+                flowQueue.closeInput();
+                const startTime = Date.now();
+                await flowQueue.awaitCompletion();
+                const endTime = Date.now();
+                expect(endTime - startTime).toBeGreaterThanOrEqual(80); // 至少处理了3个输入
+                expect(flowQueue['processedInputs'].length).toBe(3);
+                expect(flowQueue['pendingInputs'].length).toBe(0);
+            });
+        });
+        describe('isCompleted 属性', () => {
+            it('初始状态应该为 false', () => {
+                expect(flowQueue.isCompleted).toBe(false);
+            });
+            it('只调用 closeInput 但有待处理输入时应该为 false', () => {
+                const testInput = { id: 1, data: 'test' };
+                flowQueue.input(testInput);
+                flowQueue.closeInput();
+                expect(flowQueue.isCompleted).toBe(false);
+            });
+            it('调用 closeInput 且没有待处理输入时应该为 true', () => {
+                flowQueue.closeInput();
+                expect(flowQueue.isCompleted).toBe(true);
+            });
+            it('处理完所有输入后应该为 true', async () => {
+                const testInput = { id: 1, data: 'test' };
+                const expectedOutput = { id: 1, result: 'success', timestamp: Date.now() };
+                mockProcessor = vi.fn().mockResolvedValue(expectedOutput);
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+                flowQueue.input(testInput);
+                flowQueue.closeInput();
+                await flowQueue.awaitCompletion();
+                expect(flowQueue.isCompleted).toBe(true);
+            });
+            it('在处理过程中应该为 false', async () => {
+                const testInput = { id: 1, data: 'test' };
+                mockProcessor = vi.fn().mockImplementation(async () => {
+                    expect(flowQueue.isCompleted).toBe(false); // 处理过程中应该为 false
+                    await new Promise(resolve => setTimeout(resolve, 50));
+                    return { id: 1, result: 'success', timestamp: Date.now() };
+                });
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+                flowQueue.input(testInput);
+                flowQueue.closeInput();
+                await flowQueue.awaitCompletion();
+                expect(flowQueue.isCompleted).toBe(true);
+            });
+        });
+        describe('cancel 方法', () => {
+            it('应该清除待处理的输入', async () => {
+                const inputs = [
+                    { id: 1, data: 'test1' },
+                    { id: 2, data: 'test2' },
+                    { id: 3, data: 'test3' }
+                ];
+                // 使用慢速处理器确保输入还在队列中
+                mockProcessor = vi.fn().mockImplementation(async () => {
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                    return { id: 1, result: 'test', timestamp: Date.now() };
+                });
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+                flowQueue.input(...inputs);
+                // 立即取消，此时可能第一个已经开始处理，但后续的应该还在队列中
+                flowQueue.cancel();
+                expect(flowQueue['pendingInputs'].length).toBe(0);
+            });
+            it('应该清除重试计数', () => {
+                const testInput = { id: 1, data: 'test' };
+                // 手动设置重试计数来模拟重试状态
+                flowQueue['retryCount'].set(testInput, 2);
+                expect(flowQueue['retryCount'].has(testInput)).toBe(true);
+                flowQueue.cancel();
+                expect(flowQueue['retryCount'].has(testInput)).toBe(false);
+            });
+            it('应该标记为完成状态', async () => {
+                const testInput = { id: 1, data: 'test' };
+                flowQueue.input(testInput);
+                expect(flowQueue.isCompleted).toBe(false);
+                // 立即取消，这时队列应该立即变为完成状态
+                flowQueue.cancel();
+                // 等待一个短暂的时间确保取消操作完成
+                await new Promise(resolve => setTimeout(resolve, 10));
+                expect(flowQueue.isCompleted).toBe(true);
+                expect(flowQueue['isInputClosed']).toBe(true);
+            });
+            it('应该立即解决完成 Promise', async () => {
+                const testInput = { id: 1, data: 'test' };
+                flowQueue.input(testInput);
+                const completionPromise = flowQueue.awaitCompletion();
+                flowQueue.cancel();
+                await expect(completionPromise).resolves.toBeUndefined();
+            });
+        });
+        describe('reset 方法', () => {
+            it('应该清空所有数据状态', async () => {
+                const inputs = [
+                    { id: 1, data: 'test1' },
+                    { id: 2, data: 'test2' }
+                ];
+                mockProcessor = vi.fn().mockImplementation(async (input) => {
+                    return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+                });
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+                // 添加输入并处理
+                flowQueue.input(...inputs);
+                await new Promise(resolve => setTimeout(resolve, 100));
+                // 验证有数据
+                expect(flowQueue['processedInputs'].length).toBeGreaterThan(0);
+                expect(flowQueue.successOutputs.size).toBeGreaterThan(0);
+                // 重置
+                flowQueue.reset();
+                // 验证所有数据被清空
+                expect(flowQueue['pendingInputs'].length).toBe(0);
+                expect(flowQueue['processedInputs'].length).toBe(0);
+                expect(flowQueue.successOutputs.size).toBe(0);
+                expect(flowQueue['retryCount'].size).toBe(0);
+                expect(flowQueue['isProcessing']).toBe(false);
+                expect(flowQueue['isInputClosed']).toBe(false);
+                expect(flowQueue['completionPromise']).toBe(null);
+                expect(flowQueue['completionResolve']).toBe(null);
+            });
+            it('重置后应该能重新开始处理', async () => {
+                const firstInput = { id: 1, data: 'first' };
+                const secondInput = { id: 2, data: 'second' };
+                mockProcessor = vi.fn().mockImplementation(async (input) => {
+                    return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+                });
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+                // 第一轮处理
+                flowQueue.input(firstInput);
+                flowQueue.closeInput();
+                await flowQueue.awaitCompletion();
+                expect(flowQueue.isCompleted).toBe(true);
+                expect(flowQueue.successOutputs.size).toBe(1);
+                // 重置
+                flowQueue.reset();
+                // 第二轮处理
+                flowQueue.input(secondInput);
+                flowQueue.closeInput();
+                await flowQueue.awaitCompletion();
+                expect(flowQueue.isCompleted).toBe(true);
+                expect(flowQueue.successOutputs.size).toBe(1); // 只有第二轮的结果
+                expect(flowQueue.successOutputs.has(firstInput)).toBe(false); // 第一轮的结果被清除
+                expect(flowQueue.successOutputs.has(secondInput)).toBe(true); // 第二轮的结果存在
+            });
+            it('应该解决待解决的完成 Promise', async () => {
+                const testInput = { id: 1, data: 'test' };
+                // 使用慢速处理器
+                mockProcessor = vi.fn().mockImplementation(async () => {
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                    return { id: 1, result: 'test', timestamp: Date.now() };
+                });
+                flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+                flowQueue.input(testInput);
+                flowQueue.closeInput();
+                const completionPromise = flowQueue.awaitCompletion();
+                // 立即重置，应该解决 Promise
+                flowQueue.reset();
+                await expect(completionPromise).resolves.toBeUndefined();
+            });
+        });
+    });
+    describe('两个 FlowQueue 结合使用场景', () => {
+        let firstQueue;
+        let secondQueue;
+        let firstProcessor;
+        let secondProcessor;
+        beforeEach(() => {
+            firstProcessor = vi.fn();
+            secondProcessor = vi.fn();
+            firstQueue = new FlowQueue({ retry: { maxRetries: 2 } }, firstProcessor);
+            secondQueue = new FlowQueue({ retry: { maxRetries: 2 } }, secondProcessor);
+        });
+        it('应该实现流水线处理：第一个队列的输出作为第二个队列的输入', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' }
+            ];
+            // 第一个处理器：转换数据
+            firstProcessor = vi.fn().mockImplementation(async (input) => {
+                await new Promise(resolve => setTimeout(resolve, 20));
+                return {
+                    id: input.id,
+                    result: `processed_${input.data}`,
+                    timestamp: Date.now()
+                };
+            });
+            // 第二个处理器：进一步处理
+            secondProcessor = vi.fn().mockImplementation(async (input) => {
+                await new Promise(resolve => setTimeout(resolve, 20));
+                return {
+                    id: input.id,
+                    finalResult: `final_${input.result}`,
+                    processedAt: Date.now()
+                };
+            });
+            firstQueue = new FlowQueue({ retry: { maxRetries: 2 } }, firstProcessor);
+            secondQueue = new FlowQueue({ retry: { maxRetries: 2 } }, secondProcessor);
+            // 设置第一个队列的输出回调，将结果传递给第二个队列
+            firstQueue.onGenerate((output) => {
+                secondQueue.input(output);
+            });
+            // 开始处理
+            firstQueue.input(...inputs);
+            firstQueue.closeInput();
+            // 等待第一个队列完成
+            await firstQueue.awaitCompletion();
+            // 关闭第二个队列的输入
+            secondQueue.closeInput();
+            // 等待第二个队列完成
+            await secondQueue.awaitCompletion();
+            // 验证处理结果
+            expect(firstQueue.isCompleted).toBe(true);
+            expect(secondQueue.isCompleted).toBe(true);
+            expect(firstProcessor).toHaveBeenCalledTimes(3);
+            expect(secondProcessor).toHaveBeenCalledTimes(3);
+            // 验证数据流转
+            inputs.forEach(input => {
+                const firstOutput = firstQueue.successOutputs.get(input);
+                expect(firstOutput.result).toBe(`processed_${input.data}`);
+                const secondOutput = secondQueue.successOutputs.get(firstOutput);
+                expect(secondOutput).toBeDefined();
+                expect(secondOutput.finalResult).toBe(`final_processed_${input.data}`);
+            });
+        });
+        it('应该处理并行处理场景：两个队列同时处理相同输入', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' }
+            ];
+            // 第一个处理器：快速处理
+            firstProcessor = vi.fn().mockImplementation(async (input) => {
+                await new Promise(resolve => setTimeout(resolve, 10));
+                return {
+                    id: input.id,
+                    result: `fast_${input.data}`,
+                    timestamp: Date.now()
+                };
+            });
+            // 第二个处理器：慢速处理
+            const slowProcessor = vi.fn().mockImplementation(async (input) => {
+                await new Promise(resolve => setTimeout(resolve, 50));
+                return {
+                    id: input.id,
+                    result: `slow_${input.data}`,
+                    timestamp: Date.now()
+                };
+            });
+            firstQueue = new FlowQueue({ retry: { maxRetries: 2 } }, firstProcessor);
+            const slowQueue = new FlowQueue({ retry: { maxRetries: 2 } }, slowProcessor);
+            // 同时向两个队列添加相同输入
+            firstQueue.input(...inputs);
+            slowQueue.input(...inputs);
+            firstQueue.closeInput();
+            slowQueue.closeInput();
+            // 等待两个队列都完成
+            await Promise.all([
+                firstQueue.awaitCompletion(),
+                slowQueue.awaitCompletion()
+            ]);
+            // 验证两个队列都完成了处理
+            expect(firstQueue.isCompleted).toBe(true);
+            expect(slowQueue.isCompleted).toBe(true);
+            // 验证处理结果
+            inputs.forEach(input => {
+                const fastOutput = firstQueue.successOutputs.get(input);
+                const slowOutput = slowQueue.successOutputs.get(input);
+                expect(fastOutput.result).toBe(`fast_${input.data}`);
+                expect(slowOutput.result).toBe(`slow_${input.data}`);
+            });
+        });
+        it('应该处理错误传播场景：第一个队列的错误不影响第二个队列', async () => {
+            const inputs = [
+                { id: 1, data: 'success' },
+                { id: 2, data: 'fail' },
+                { id: 3, data: 'success' }
+            ];
+            // 第一个处理器：部分失败
+            firstProcessor = vi.fn().mockImplementation(async (input) => {
+                if (input.data === 'fail') {
+                    throw new Error('Processing failed');
+                }
+                return {
+                    id: input.id,
+                    result: `processed_${input.data}`,
+                    timestamp: Date.now()
+                };
+            });
+            // 第二个处理器：正常处理
+            secondProcessor = vi.fn().mockImplementation(async (input) => {
+                return {
+                    id: input.id,
+                    finalResult: `final_${input.result}`,
+                    processedAt: Date.now()
+                };
+            });
+            firstQueue = new FlowQueue({ retry: { maxRetries: 1 } }, firstProcessor);
+            secondQueue = new FlowQueue({ retry: { maxRetries: 1 } }, secondProcessor);
+            // 只有成功的输出才传递给第二个队列
+            firstQueue.onGenerate((output) => {
+                secondQueue.input(output);
+            });
+            firstQueue.input(...inputs);
+            firstQueue.closeInput();
+            await firstQueue.awaitCompletion();
+            secondQueue.closeInput();
+            await secondQueue.awaitCompletion();
+            // 验证第一个队列有一个错误
+            const failedInput = inputs.find(i => i.data === 'fail');
+            const failedResult = firstQueue.erroredOutputs.get(failedInput);
+            expect(failedResult).toBeInstanceOf(Error);
+            expect(failedResult.message).toBe('Processing failed');
+            // 验证第二个队列只处理了成功的输出
+            expect(firstProcessor).toHaveBeenCalledTimes(4); // 3次初始 + 1次重试
+            expect(secondProcessor).toHaveBeenCalledTimes(2); // 只有2个成功的输出
+            expect(secondQueue.isCompleted).toBe(true);
+        });
+        it('应该支持条件分发：根据第一个队列的结果决定后续处理', async () => {
+            const inputs = [
+                { id: 1, data: 'priority_high' },
+                { id: 2, data: 'priority_low' },
+                { id: 3, data: 'priority_high' },
+                { id: 4, data: 'priority_medium' }
+            ];
+            firstProcessor = vi.fn().mockImplementation(async (input) => {
+                return {
+                    id: input.id,
+                    result: input.data,
+                    timestamp: Date.now()
+                };
+            });
+            secondProcessor = vi.fn().mockImplementation(async (input) => {
+                return {
+                    id: input.id,
+                    finalResult: `high_priority_${input.result}`,
+                    processedAt: Date.now()
+                };
+            });
+            const lowPriorityProcessor = vi.fn().mockImplementation(async (input) => {
+                return {
+                    id: input.id,
+                    finalResult: `low_priority_${input.result}`,
+                    processedAt: Date.now()
+                };
+            });
+            firstQueue = new FlowQueue({ retry: { maxRetries: 2 } }, firstProcessor);
+            const highPriorityQueue = new FlowQueue({ retry: { maxRetries: 2 } }, secondProcessor);
+            const lowPriorityQueue = new FlowQueue({ retry: { maxRetries: 2 } }, lowPriorityProcessor); // 根据结果条件分发
+            firstQueue.onGenerate((output) => {
+                if (output.result.includes('high')) {
+                    highPriorityQueue.input(output);
+                }
+                else {
+                    lowPriorityQueue.input(output);
+                }
+            });
+            firstQueue.input(...inputs);
+            firstQueue.closeInput();
+            await firstQueue.awaitCompletion();
+            highPriorityQueue.closeInput();
+            lowPriorityQueue.closeInput();
+            await Promise.all([
+                highPriorityQueue.awaitCompletion(),
+                lowPriorityQueue.awaitCompletion()
+            ]);
+            // 验证分发逻辑
+            expect(secondProcessor).toHaveBeenCalledTimes(2); // 2个高优先级
+            expect(lowPriorityProcessor).toHaveBeenCalledTimes(2); // 2个非高优先级
+            // 验证所有队列都完成
+            expect(firstQueue.isCompleted).toBe(true);
+            expect(highPriorityQueue.isCompleted).toBe(true);
+            expect(lowPriorityQueue.isCompleted).toBe(true);
+        });
+        it('应该处理级联取消场景：取消第一个队列时自动取消后续队列', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' },
+                { id: 4, data: 'test4' },
+                { id: 5, data: 'test5' }
+            ];
+            firstProcessor = vi.fn().mockImplementation(async (input) => {
+                await new Promise(resolve => setTimeout(resolve, 30));
+                return {
+                    id: input.id,
+                    result: `processed_${input.data}`,
+                    timestamp: Date.now()
+                };
+            });
+            secondProcessor = vi.fn().mockImplementation(async (input) => {
+                await new Promise(resolve => setTimeout(resolve, 30));
+                return {
+                    id: input.id,
+                    finalResult: `final_${input.result}`,
+                    processedAt: Date.now()
+                };
+            });
+            firstQueue = new FlowQueue({ retry: { maxRetries: 2 } }, firstProcessor);
+            secondQueue = new FlowQueue({ retry: { maxRetries: 2 } }, secondProcessor);
+            let cancelSecondQueue = false;
+            firstQueue.onGenerate((output) => {
+                if (!cancelSecondQueue) {
+                    secondQueue.input(output);
+                }
+            });
+            firstQueue.input(...inputs);
+            // 等待一些处理开始
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // 取消第一个队列，并标记不再向第二个队列添加输入
+            cancelSecondQueue = true;
+            firstQueue.cancel();
+            secondQueue.cancel();
+            // 等待取消操作完成和所有异步操作结束
+            await Promise.all([
+                firstQueue.awaitCompletion(),
+                secondQueue.awaitCompletion()
+            ]);
+            // 验证取消状态
+            expect(firstQueue.isCompleted).toBe(true);
+            expect(secondQueue.isCompleted).toBe(true);
+            expect(firstQueue['pendingInputs'].length).toBe(0);
+            expect(secondQueue['pendingInputs'].length).toBe(0);
+            // 等待确保没有更多处理
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // 验证处理被中断 - 由于异步操作的时序不确定性，我们只验证处理确实被中断了
+            const firstCallCount = firstProcessor.mock.calls.length;
+            const secondCallCount = secondProcessor.mock.calls.length;
+            // 主要验证：处理次数应该少于总输入数，说明确实被取消了
+            expect(firstCallCount).toBeLessThan(inputs.length);
+            expect(secondCallCount).toBeLessThan(inputs.length);
+        });
+        it('应该支持重置功能', async () => {
+            const inputs = [
+                { id: 1, data: 'success' },
+                { id: 2, data: 'success' },
+                { id: 3, data: 'success' }
+            ];
+            // 第一次处理器
+            firstProcessor = vi.fn().mockImplementation(async (input) => {
+                return {
+                    id: input.id,
+                    result: `processed_${input.data}`,
+                    timestamp: Date.now()
+                };
+            });
+            firstQueue = new FlowQueue({ retry: { maxRetries: 0 } }, firstProcessor);
+            // 第一轮处理
+            firstQueue.input(...inputs);
+            await new Promise(resolve => setTimeout(resolve, 100));
+            // 验证处理结果
+            expect(firstQueue.successOutputs.size).toBe(3);
+            // 测试重置功能
+            firstQueue.reset();
+            expect(firstQueue.successOutputs.size).toBe(0);
+            expect(firstQueue['processedInputs'].length).toBe(0);
+            expect(firstQueue.isCompleted).toBe(false);
+            // 重置后重新处理
+            firstQueue.input(...inputs);
+            firstQueue.closeInput();
+            await firstQueue.awaitCompletion();
+            // 验证重置后的处理结果
+            expect(firstQueue.successOutputs.size).toBe(3);
+            expect(firstQueue.isCompleted).toBe(true);
+            inputs.forEach(input => {
+                const output = firstQueue.successOutputs.get(input);
+                expect(output.result).toBe(`processed_${input.data}`);
+            });
+        });
+    });
+});