@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

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

@@ -0,0 +1,640 @@
+/**
+ * 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