@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

package/dist/core/src/env/workflow/engine/workflow-engine.test.js

@@ -1,640 +0,0 @@
-/**
- * WorkflowEngine Integration Tests
- *
- * Tests for the WorkflowEngine class including:
- * - Session ID generation and formatting
- * - @TracedAs decorator presence
- * - Basic engine state management
- * - Method signatures
- */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { WorkflowEngine } from "./engine.js";
-import { DAGManager } from "./dag-manager.js";
-// ==================== Mock Dependencies ====================
-/**
- * Create a minimal mock NodeRegistry for testing
- */
-function createMockNodeRegistry() {
-    // Create a minimal implementation that satisfies the interface
-    const mockGetNodeConfig = vi.fn();
-    const mockCreateExecutorContext = vi.fn();
-    return {
-        getNodeConfig: mockGetNodeConfig,
-        createExecutorContext: mockCreateExecutorContext,
-    };
-}
-/**
- * Create a mock SessionComponent for testing
- */
-function createMockSessionComponent() {
-    const sessions = new Map();
-    const messages = new Map();
-    // Create implementations first
-    const createImpl = async (session) => {
-        sessions.set(session.id, {
-            ...session,
-            metadata: session.metadata || {},
-        });
-        messages.set(session.id, []);
-        return session;
-    };
-    const getImpl = async (sessionId) => {
-        return sessions.get(sessionId) || null;
-    };
-    const updateImpl = async (sessionId, updates) => {
-        const session = sessions.get(sessionId);
-        if (session) {
-            Object.assign(session, updates);
-        }
-        return session;
-    };
-    const addMessageImpl = async (sessionId, message) => {
-        const msgs = messages.get(sessionId) || [];
-        msgs.push(message);
-        messages.set(sessionId, msgs);
-        return message;
-    };
-    const getMessagesImpl = async (sessionId) => {
-        return messages.get(sessionId) || [];
-    };
-    const clearImpl = () => {
-        sessions.clear();
-        messages.clear();
-    };
-    return {
-        sessions,
-        messages,
-        create: vi.fn(createImpl),
-        get: vi.fn(getImpl),
-        update: vi.fn(updateImpl),
-        addMessage: vi.fn(addMessageImpl),
-        getMessages: vi.fn(getMessagesImpl),
-        clear: vi.fn(clearImpl),
-    };
-}
-// ==================== Test Suite ====================
-describe('WorkflowEngine', () => {
-    let mockNodeRegistry;
-    let mockSessionComponent;
-    beforeEach(() => {
-        mockNodeRegistry = createMockNodeRegistry();
-        mockSessionComponent = createMockSessionComponent();
-    });
-    // ==================== Constructor and Factory ====================
-    describe('constructor', () => {
-        it('should create engine with NodeRegistry', () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            expect(engine).toBeDefined();
-            // WorkflowEngine extends EventEmitter - verify basic functionality
-            expect(typeof engine.on).toBe('function');
-            expect(typeof engine.emit).toBe('function');
-        });
-        it('should create engine with NodeRegistry and SessionComponent', () => {
-            const engine = new WorkflowEngine(mockNodeRegistry, mockSessionComponent);
-            expect(engine).toBeDefined();
-        });
-        it('should create engine with all dependencies', () => {
-            const mockWorkflowRepo = {
-                getById: vi.fn(),
-                getByName: vi.fn(),
-            };
-            const engine = new WorkflowEngine(mockNodeRegistry, mockSessionComponent, mockWorkflowRepo);
-            expect(engine).toBeDefined();
-        });
-    });
-    // ==================== Session ID Methods ====================
-    describe('getSessionId', () => {
-        it('should generate correct session ID format', () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            const runId = 'run_12345_1_abc123';
-            const sessionId = engine.getSessionId(runId);
-            expect(sessionId).toBe('workflow_run_12345_1_abc123');
-            expect(sessionId.startsWith('workflow_')).toBe(true);
-        });
-        it('should handle different run ID formats', () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            // Test various run ID formats
-            expect(engine.getSessionId('run_1')).toBe('workflow_run_1');
-            expect(engine.getSessionId('run_123')).toBe('workflow_run_123');
-            expect(engine.getSessionId('simple')).toBe('workflow_simple');
-        });
-    });
-    // ==================== Session Creation ====================
-    describe('createSession', () => {
-        it('should create session with correct metadata', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry, mockSessionComponent);
-            // New API: first argument is WorkflowDefinition or Workflow
-            const workflow = {
-                name: 'Test Workflow',
-                version: '1.0',
-                nodes: [],
-            };
-            const sessionId = await engine.createSession(workflow, {
-                input: { test: 'data' },
-            });
-            // Verify session was created with correct ID format
-            expect(sessionId.startsWith('workflow_')).toBe(true);
-            // Verify session metadata
-            expect(mockSessionComponent.create).toHaveBeenCalledTimes(1);
-            const createCall = mockSessionComponent.create.mock.calls[0][0];
-            expect(createCall.id).toBe(sessionId);
-            expect(createCall.metadata.type).toBe('workflow');
-            // workflowId is derived from workflow.id or 'inline_' + workflow.name
-            expect(createCall.metadata.workflowId).toBe('inline_Test Workflow');
-            expect(createCall.metadata.workflowName).toBe('Test Workflow');
-            expect(createCall.metadata.status).toBe('running');
-            expect(createCall.metadata.input).toEqual({ test: 'data' });
-        });
-        it('should create session without SessionComponent', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            const workflow = {
-                name: 'test-workflow',
-                version: '1.0',
-                nodes: [],
-            };
-            const sessionId = await engine.createSession(workflow);
-            // Should still return session ID even without SessionComponent
-            expect(sessionId).toBeDefined();
-            expect(sessionId.startsWith('workflow_')).toBe(true);
-        });
-        it('should include workflow version in metadata when provided', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry, mockSessionComponent);
-            const workflow = {
-                name: 'Test Workflow',
-                version: '2.0.0',
-                nodes: [],
-            };
-            await engine.createSession(workflow);
-            const createCall = mockSessionComponent.create.mock.calls[0][0];
-            expect(createCall.metadata.workflowVersion).toBe('2.0.0');
-        });
-        it('should use Unknown as default workflow name', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry, mockSessionComponent);
-            const workflow = {
-                name: 'test-workflow',
-                version: '1.0',
-                nodes: [],
-            };
-            await engine.createSession(workflow);
-            const createCall = mockSessionComponent.create.mock.calls[0][0];
-            expect(createCall.metadata.workflowName).toBe('test-workflow');
-        });
-    });
-    // ==================== Session Status Methods ====================
-    describe('getSessionStatus', () => {
-        it('should return null for non-existent session', () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            const status = engine.getSessionStatus('non-existent-session');
-            expect(status).toBeNull();
-        });
-    });
-    describe('isSessionActive', () => {
-        it('should return false for non-existent session', () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            expect(engine.isSessionActive('non-existent-session')).toBe(false);
-        });
-    });
-    // ==================== @TracedAs Decorator Tests ====================
-    describe('@TracedAs decorator presence', () => {
-        it('should have TracedAs on createSession method', async () => {
-            // The @TracedAs decorator wraps methods, so we verify it by checking
-            // the method exists and has expected behavior
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            expect(typeof engine.createSession).toBe('function');
-            // The method should be traceable - verify it with proper WorkflowDefinition
-            const workflow = {
-                name: 'test',
-                version: '1.0',
-                nodes: [],
-            };
-            const sessionId = await engine.createSession(workflow);
-            expect(typeof sessionId).toBe('string');
-            expect(sessionId.startsWith('workflow_')).toBe(true);
-        });
-        it('should have TracedAs on run method', () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            expect(typeof engine.run).toBe('function');
-        });
-        it('should have TracedAs on runWorkflow method', () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            expect(typeof engine.runWorkflow).toBe('function');
-        });
-        it('should have TracedAs on pause method', () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            expect(typeof engine.pause).toBe('function');
-        });
-        it('should have TracedAs on stop method', () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            expect(typeof engine.stop).toBe('function');
-        });
-        // Note: The actual @TracedAs decorator behavior would be tested in
-        // integration tests that verify trace context propagation.
-        // Here we verify the methods exist and are callable.
-    });
-    // ==================== Static Factory Method ====================
-    describe('static create', () => {
-        it('should create engine via static factory', async () => {
-            const mockEnv = {
-                getComponent: vi.fn((name) => {
-                    if (name === 'agent')
-                        return { /* mock agent */};
-                    if (name === 'session')
-                        return mockSessionComponent;
-                    return undefined;
-                }),
-            };
-            const engine = await WorkflowEngine.create({
-                env: mockEnv,
-            });
-            expect(engine).toBeDefined();
-            expect(engine).toBeInstanceOf(WorkflowEngine);
-        });
-        it('should pass components to NodeRegistry', async () => {
-            const mockAgent = { name: 'mock-agent' };
-            const mockEnv = {
-                getComponent: vi.fn((name) => {
-                    if (name === 'agent')
-                        return mockAgent;
-                    return undefined;
-                }),
-            };
-            const engine = await WorkflowEngine.create({
-                env: mockEnv,
-            });
-            expect(engine).toBeDefined();
-            expect(mockEnv.getComponent).toHaveBeenCalledWith('agent');
-        });
-    });
-    // ==================== Run Method Tests ====================
-    describe('run', () => {
-        it('should throw error for new session without workflowId', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            await expect(engine.run('new-session-id')).rejects.toThrow('workflowId required for new session');
-        });
-        it('should return completed status for completed session', async () => {
-            // Setup: Create a session with completed status
-            const completedSession = {
-                id: 'workflow_completed',
-                title: 'Test',
-                metadata: {
-                    type: 'workflow',
-                    workflowId: 'test-workflow',
-                    workflowName: 'test-workflow',
-                    status: 'completed',
-                },
-            };
-            // Mock the session component to return the completed session
-            const mockSC = createMockSessionComponent();
-            mockSC.sessions.set('workflow_completed', completedSession);
-            mockSC.get.mockResolvedValueOnce(completedSession);
-            // Mock workflow repository to return a valid workflow
-            const mockRepo = {
-                getById: vi.fn().mockReturnValue({
-                    id: 'test-workflow',
-                    definition: {
-                        name: 'test-workflow',
-                        version: '1.0',
-                        nodes: [{ id: 'a', type: 'tool', config: {} }],
-                    },
-                }),
-                getByName: vi.fn(),
-            };
-            const engine = new WorkflowEngine(mockNodeRegistry, mockSC, mockRepo);
-            const result = await engine.run('workflow_completed');
-            expect(result.status).toBe('completed');
-        });
-        it('should return failed status for failed session', async () => {
-            const failedSession = {
-                id: 'workflow_failed',
-                title: 'Test',
-                metadata: {
-                    type: 'workflow',
-                    workflowId: 'test-workflow',
-                    workflowName: 'test-workflow',
-                    status: 'failed',
-                },
-            };
-            // Mock the session component to return the failed session
-            const mockSC = createMockSessionComponent();
-            mockSC.sessions.set('workflow_failed', failedSession);
-            mockSC.get.mockResolvedValueOnce(failedSession);
-            // Mock workflow repository to return a valid workflow
-            const mockRepo = {
-                getById: vi.fn().mockReturnValue({
-                    id: 'test-workflow',
-                    definition: {
-                        name: 'test-workflow',
-                        version: '1.0',
-                        nodes: [{ id: 'a', type: 'tool', config: {} }],
-                    },
-                }),
-                getByName: vi.fn(),
-            };
-            const engine = new WorkflowEngine(mockNodeRegistry, mockSC, mockRepo);
-            const result = await engine.run('workflow_failed');
-            expect(result.status).toBe('failed');
-        });
-        // SKIP: Full run/resume tests require extensive mocking of DAGManager, Scheduler, Executor
-        it.skip('should start from entry node on fresh run - requires full integration', () => {
-            // This would require mocking DAGManager, Scheduler, Executor
-            // and verifying that execution starts from the workflow's entry node
-        });
-        it.skip('should validate recovery before execution on resume - requires full integration', () => {
-            // This would require setting up a paused session with messages
-            // and verifying that inferNextNode is called correctly
-        });
-    });
-    // ==================== Stop Method Tests ====================
-    describe('stop', () => {
-        it('should return without error for non-existent session', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            // New implementation returns void without throwing for non-existent session
-            await expect(engine.stop('non-existent')).resolves.toBeUndefined();
-        });
-        // SKIP: Full stop tests require active run state
-        it.skip('should update session status to stopped - requires active run', async () => {
-            // This requires an active run which is managed internally
-            // The test would need to trigger a workflow run and then stop it
-        });
-    });
-    // ==================== Pause Method Tests ====================
-    describe('pause', () => {
-        it('should throw error for non-existent session', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            await expect(engine.pause('non-existent')).rejects.toThrow('Session not found');
-        });
-        it('should throw error for non-running session', async () => {
-            // Create an engine with a session that's not in activeRuns
-            const engine = new WorkflowEngine(mockNodeRegistry, mockSessionComponent);
-            // Even if session exists in sessionComponent, it's not in activeRuns
-            // so we should get "Session not found"
-            await expect(engine.pause('any-session')).rejects.toThrow('Session not found');
-        });
-        // SKIP: Full pause tests require active run state
-        it.skip('should update session status to paused - requires active run', () => {
-            // This requires an active run which is managed internally
-        });
-    });
-    // ==================== RunWorkflow Method Tests ====================
-    describe('runWorkflow', () => {
-        it.skip('should execute workflow with valid definition - requires full integration', () => {
-            // This would require extensive mocking of the execution pipeline
-        });
-        it.skip('should validate DAG before execution - requires full integration', () => {
-            // This would require testing with an invalid workflow definition
-        });
-    });
-    // ==================== Internal Method Tests ====================
-    describe('internal methods', () => {
-        it('should generate unique run IDs', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            // Access internal generator through createSession
-            const workflow1 = {
-                name: 'wf1',
-                version: '1.0',
-                nodes: [],
-            };
-            const workflow2 = {
-                name: 'wf2',
-                version: '1.0',
-                nodes: [],
-            };
-            const sessionId1 = await engine.createSession(workflow1);
-            const sessionId2 = await engine.createSession(workflow2);
-            // Each session should have a unique run ID portion
-            expect(sessionId1).not.toBe(sessionId2);
-        });
-        it('should parse workflow ID from session ID', () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            const runId = 'run_123_1_abc';
-            const sessionId = `workflow_${runId}`;
-            const parsedRunId = sessionId.replace('workflow_', '');
-            expect(parsedRunId).toBe(runId);
-        });
-    });
-    // ==================== Event Emission Tests ====================
-    describe('event emission', () => {
-        it('should extend EventEmitter', () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            const eventHandler = vi.fn();
-            engine.on('test-event', eventHandler);
-            engine.emit('test-event', { data: 'test' });
-            expect(eventHandler).toHaveBeenCalledTimes(1);
-        });
-    });
-    // ==================== Error Handling Tests ====================
-    describe('error handling', () => {
-        it('should handle sessionComponent errors gracefully in createSession', async () => {
-            const failingSessionComponent = {
-                create: vi.fn().mockRejectedValue(new Error('DB connection failed')),
-            };
-            const engine = new WorkflowEngine(mockNodeRegistry, failingSessionComponent);
-            const workflow = {
-                name: 'test',
-                version: '1.0',
-                nodes: [],
-            };
-            // The error should propagate
-            await expect(engine.createSession(workflow)).rejects.toThrow('DB connection failed');
-        });
-        it('should handle missing workflow definition', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry);
-            // Trying to run with a workflowId that doesn't exist in the repository
-            await expect(engine.run('new-session', { workflowId: 'non-existent-workflow' })).rejects.toThrow('Workflow not found');
-        });
-    });
-});
-// ==================== WorkflowEngine with DAGManager Integration ====================
-describe('WorkflowEngine DAG Integration', () => {
-    let mockNodeRegistry;
-    beforeEach(() => {
-        mockNodeRegistry = createMockNodeRegistry();
-    });
-    describe('DAG validation', () => {
-        it('should use DAGManager for workflow validation', () => {
-            // Verify DAGManager can be instantiated with a workflow
-            const workflow = {
-                name: 'test-workflow',
-                version: '1.0',
-                nodes: [
-                    { id: 'a', type: 'tool', config: {} },
-                    { id: 'b', type: 'tool', config: {}, depends_on: ['a'] },
-                ],
-            };
-            const dagManager = new DAGManager(workflow);
-            const validation = dagManager.validate();
-            expect(validation.valid).toBe(true);
-        });
-        it('should detect invalid DAGs', () => {
-            const invalidWorkflow = {
-                name: 'invalid-workflow',
-                version: '1.0',
-                nodes: [
-                    { id: 'a', type: 'tool', config: {} },
-                    { id: 'b', type: 'tool', config: {}, depends_on: ['c'] }, // References non-existent node
-                ],
-            };
-            const dagManager = new DAGManager(invalidWorkflow);
-            const validation = dagManager.validate();
-            expect(validation.valid).toBe(false);
-            expect(validation.errors.length).toBeGreaterThan(0);
-        });
-        it('should detect circular dependencies', () => {
-            const circularWorkflow = {
-                name: 'circular-workflow',
-                version: '1.0',
-                nodes: [
-                    { id: 'a', type: 'tool', config: {}, depends_on: ['b'] },
-                    { id: 'b', type: 'tool', config: {}, depends_on: ['a'] },
-                ],
-            };
-            const dagManager = new DAGManager(circularWorkflow);
-            const validation = dagManager.validate();
-            expect(validation.valid).toBe(false);
-        });
-    });
-    describe('DAG analysis', () => {
-        it('should identify entry nodes', () => {
-            const workflow = {
-                name: 'test',
-                nodes: [
-                    { id: 'a', type: 'tool', config: {} },
-                    { id: 'b', type: 'tool', config: {} },
-                    { id: 'c', type: 'tool', config: {}, depends_on: ['a', 'b'] },
-                ],
-            };
-            const dagManager = new DAGManager(workflow);
-            const analysis = dagManager.analyze();
-            expect(analysis.entryNodes).toContain('a');
-            expect(analysis.entryNodes).toContain('b');
-            expect(analysis.entryNodes).not.toContain('c');
-        });
-        it('should identify exit nodes', () => {
-            const workflow = {
-                name: 'test',
-                nodes: [
-                    { id: 'a', type: 'tool', config: {} },
-                    { id: 'b', type: 'tool', config: {}, depends_on: ['a'] },
-                    { id: 'c', type: 'tool', config: {} },
-                ],
-            };
-            const dagManager = new DAGManager(workflow);
-            const analysis = dagManager.analyze();
-            expect(analysis.exitNodes).toContain('b');
-            expect(analysis.exitNodes).toContain('c');
-        });
-    });
-});
-// ==================== Session ID Format Tests ====================
-describe('Session ID Format', () => {
-    let mockNodeRegistry;
-    beforeEach(() => {
-        mockNodeRegistry = createMockNodeRegistry();
-    });
-    it('should generate session ID with workflow_ prefix', () => {
-        const engine = new WorkflowEngine(mockNodeRegistry);
-        const sessionId = engine.getSessionId('run_123');
-        expect(sessionId.startsWith('workflow_')).toBe(true);
-    });
-    it('should preserve run ID in session ID', () => {
-        const engine = new WorkflowEngine(mockNodeRegistry);
-        const runId = 'run_12345_1_abc';
-        const sessionId = engine.getSessionId(runId);
-        expect(sessionId).toContain(runId);
-    });
-    it('should format session ID consistently', () => {
-        const engine = new WorkflowEngine(mockNodeRegistry);
-        const sessionId1 = engine.getSessionId('run_1');
-        const sessionId2 = engine.getSessionId('run_1');
-        expect(sessionId1).toBe(sessionId2);
-    });
-});
-// ==================== Integration Scenario Tests ====================
-describe('WorkflowEngine Integration Scenarios', () => {
-    let mockNodeRegistry;
-    let mockSessionComponent;
-    beforeEach(() => {
-        mockNodeRegistry = createMockNodeRegistry();
-        mockSessionComponent = createMockSessionComponent();
-    });
-    describe('Session lifecycle', () => {
-        it('should track session creation flow', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry, mockSessionComponent);
-            const workflow = {
-                name: 'Test Workflow',
-                version: '1.0',
-                nodes: [],
-            };
-            const sessionId = await engine.createSession(workflow);
-            expect(mockSessionComponent.create).toHaveBeenCalledTimes(1);
-            // Use the mocked get method instead of direct access
-            const createdSession = await mockSessionComponent.get(sessionId);
-            expect(createdSession).toBeDefined();
-            expect(createdSession.metadata.status).toBe('running');
-        });
-        it('should handle session metadata updates', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry, mockSessionComponent);
-            const workflow = {
-                name: 'test-workflow',
-                version: '1.0',
-                nodes: [],
-            };
-            const sessionId = await engine.createSession(workflow);
-            // Simulate updating session status
-            await mockSessionComponent.update(sessionId, {
-                metadata: { status: 'paused' },
-            });
-            // Use the mocked get method instead of direct access
-            const updatedSession = await mockSessionComponent.get(sessionId);
-            expect(updatedSession.metadata.status).toBe('paused');
-        });
-    });
-    describe('Multiple concurrent sessions', () => {
-        it('should handle multiple session creations', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry, mockSessionComponent);
-            const workflow1 = {
-                name: 'Workflow 1',
-                version: '1.0',
-                nodes: [],
-            };
-            const workflow2 = {
-                name: 'Workflow 2',
-                version: '1.0',
-                nodes: [],
-            };
-            const workflow3 = {
-                name: 'Workflow 3',
-                version: '1.0',
-                nodes: [],
-            };
-            const sessionId1 = await engine.createSession(workflow1);
-            const sessionId2 = await engine.createSession(workflow2);
-            const sessionId3 = await engine.createSession(workflow3);
-            expect(sessionId1).not.toBe(sessionId2);
-            expect(sessionId2).not.toBe(sessionId3);
-            expect(sessionId1).not.toBe(sessionId3);
-            expect(mockSessionComponent.create).toHaveBeenCalledTimes(3);
-        });
-        it('should store session metadata independently', async () => {
-            const engine = new WorkflowEngine(mockNodeRegistry, mockSessionComponent);
-            const workflow1 = {
-                name: 'First',
-                version: '1.0',
-                nodes: [],
-            };
-            const workflow2 = {
-                name: 'Second',
-                version: '1.0',
-                nodes: [],
-            };
-            const sessionId1 = await engine.createSession(workflow1);
-            const sessionId2 = await engine.createSession(workflow2);
-            // Use the mocked get method instead of direct access
-            const session1 = await mockSessionComponent.get(sessionId1);
-            const session2 = await mockSessionComponent.get(sessionId2);
-            expect(session1.metadata.workflowName).toBe('First');
-            expect(session2.metadata.workflowName).toBe('Second');
-        });
-    });
-});
-//# sourceMappingURL=workflow-engine.test.js.map