@ai-setting/roy-agent-core 1.3.9 → 1.3.11

package/src/env/workflow/engine/workflow-engine.test.ts

@@ -1,815 +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';
-import { DAGManager } from './dag-manager';
-import { NodeRegistry } from './node-registry';
-import type { WorkflowDefinition, WorkflowSessionMetadata } from '../types';
-
-// ==================== Mock Dependencies ====================
-
-/**
- * Create a minimal mock NodeRegistry for testing
- */
-function createMockNodeRegistry(): NodeRegistry {
-  // Create a minimal implementation that satisfies the interface
-  const mockGetNodeConfig = vi.fn();
-  const mockCreateExecutorContext = vi.fn();
-  
-  return {
-    getNodeConfig: mockGetNodeConfig,
-    createExecutorContext: mockCreateExecutorContext,
-  } as unknown as NodeRegistry;
-}
-
-/**
- * Create a mock SessionComponent for testing
- */
-function createMockSessionComponent() {
-  const sessions = new Map<string, any>();
-  const messages = new Map<string, any[]>();
-  
-  // Create implementations first
-  const createImpl = async (session: any) => {
-    sessions.set(session.id, {
-      ...session,
-      metadata: session.metadata || {},
-    });
-    messages.set(session.id, []);
-    return session;
-  };
-  
-  const getImpl = async (sessionId: string) => {
-    return sessions.get(sessionId) || null;
-  };
-  
-  const updateImpl = async (sessionId: string, updates: any) => {
-    const session = sessions.get(sessionId);
-    if (session) {
-      Object.assign(session, updates);
-    }
-    return session;
-  };
-  
-  const addMessageImpl = async (sessionId: string, message: any) => {
-    const msgs = messages.get(sessionId) || [];
-    msgs.push(message);
-    messages.set(sessionId, msgs);
-    return message;
-  };
-  
-  const getMessagesImpl = async (sessionId: string) => {
-    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: NodeRegistry;
-  let mockSessionComponent: ReturnType<typeof createMockSessionComponent>;
-  
-  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 as any);
-      expect(engine).toBeDefined();
-    });
-    
-    it('should create engine with all dependencies', () => {
-      const mockWorkflowRepo = {
-        getById: vi.fn(),
-        getByName: vi.fn(),
-      };
-      
-      const engine = new WorkflowEngine(
-        mockNodeRegistry,
-        mockSessionComponent as any,
-        mockWorkflowRepo as any
-      );
-      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 as any);
-      
-      // New API: first argument is WorkflowDefinition or Workflow
-      const workflow: WorkflowDefinition = {
-        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 as any).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: WorkflowDefinition = {
-        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 as any);
-      
-      const workflow: WorkflowDefinition = {
-        name: 'Test Workflow',
-        version: '2.0.0',
-        nodes: [],
-      };
-      
-      await engine.createSession(workflow);
-      
-      const createCall = (mockSessionComponent.create as any).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 as any);
-      
-      const workflow: WorkflowDefinition = {
-        name: 'test-workflow',
-        version: '1.0',
-        nodes: [],
-      };
-      
-      await engine.createSession(workflow);
-      
-      const createCall = (mockSessionComponent.create as any).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: WorkflowDefinition = {
-        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: string) => {
-          if (name === 'agent') return { /* mock agent */ };
-          if (name === 'session') return mockSessionComponent;
-          return undefined;
-        }),
-      };
-      
-      const engine = await WorkflowEngine.create({
-        env: mockEnv as any,
-      });
-      
-      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: string) => {
-          if (name === 'agent') return mockAgent;
-          return undefined;
-        }),
-      };
-      
-      const engine = await WorkflowEngine.create({
-        env: mockEnv as any,
-      });
-      
-      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 as any, mockRepo as any);
-      
-      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 as any, mockRepo as any);
-      
-      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 as any);
-      
-      // 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: WorkflowDefinition = {
-        name: 'wf1',
-        version: '1.0',
-        nodes: [],
-      };
-      const workflow2: WorkflowDefinition = {
-        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 as any);
-      
-      const workflow: WorkflowDefinition = {
-        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: NodeRegistry;
-  
-  beforeEach(() => {
-    mockNodeRegistry = createMockNodeRegistry();
-  });
-  
-  describe('DAG validation', () => {
-    it('should use DAGManager for workflow validation', () => {
-      // Verify DAGManager can be instantiated with a workflow
-      const workflow: WorkflowDefinition = {
-        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: WorkflowDefinition = {
-        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: WorkflowDefinition = {
-        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: WorkflowDefinition = {
-        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: WorkflowDefinition = {
-        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: NodeRegistry;
-  
-  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: NodeRegistry;
-  let mockSessionComponent: ReturnType<typeof createMockSessionComponent>;
-  
-  beforeEach(() => {
-    mockNodeRegistry = createMockNodeRegistry();
-    mockSessionComponent = createMockSessionComponent();
-  });
-  
-  describe('Session lifecycle', () => {
-    it('should track session creation flow', async () => {
-      const engine = new WorkflowEngine(mockNodeRegistry, mockSessionComponent as any);
-      
-      const workflow: WorkflowDefinition = {
-        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 as any);
-      
-      const workflow: WorkflowDefinition = {
-        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 as any);
-      
-      const workflow1: WorkflowDefinition = {
-        name: 'Workflow 1',
-        version: '1.0',
-        nodes: [],
-      };
-      const workflow2: WorkflowDefinition = {
-        name: 'Workflow 2',
-        version: '1.0',
-        nodes: [],
-      };
-      const workflow3: WorkflowDefinition = {
-        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 as any);
-      
-      const workflow1: WorkflowDefinition = {
-        name: 'First',
-        version: '1.0',
-        nodes: [],
-      };
-      const workflow2: WorkflowDefinition = {
-        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');
-    });
-  });
-});