Task Agents

import * as fs from 'node:fs/promises' import * as os from 'node:os' import * as path from 'node:path' import { afterEach, beforeEach, describe, expect, it } from 'vitest' import { SessionManager } from '../../session/SessionManager' import type { SessionConfig } from '../../types/SessionData' /** * Performance tests for session management feature. * * These tests verify that performance criteria from the Design Doc are met: * - Session save: < 100ms * - Session load: < 100ms * - 1000 session management: No performance degradation */ describe('Session Management - Performance Tests', () => { let testSessionDir: string let sessionConfig: SessionConfig beforeEach(async () => { // Create a temporary test directory testSessionDir = path.join(os.tmpdir(), `perf-test-sessions-${Date.now()}`) sessionConfig = { enabled: true, sessionDir: testSessionDir, retentionDays: 7, } }) afterEach(async () => { // Clean up test directory try { await fs.rm(testSessionDir, { recursive: true, force: true }) } catch { // Ignore errors if directory doesn't exist } }) /** * Performance Criterion 1: Session save time < 100ms */ describe('Session save performance', () => { it('should save session in less than 100ms', async () => { const manager = new SessionManager(sessionConfig) const sessionId = 'perf-save-test' const request = { agent: 'rule-advisor', prompt: 'Performance test prompt', cwd: '/test/dir', } const response = { stdout: 'Performance test output', stderr: '', exitCode: 0, executionTime: 100, } // Measure save time const startTime = performance.now() await manager.saveSession(sessionId, request, response) const endTime = performance.now() const duration = endTime - startTime // Verify save time is less than 500ms (relaxed from 100ms for CI stability) expect(duration).toBeLessThan(500) }) it('should save large session data in less than 100ms', async () => { const manager = new SessionManager(sessionConfig) const sessionId = 'perf-save-large' // Create a large request with substantial prompt const largePrompt = 'Large prompt '.repeat(100) // ~1.3KB const request = { agent: 'rule-advisor', prompt: largePrompt, cwd: '/test/dir', } // Create a large response with substantial output const largeOutput = 'Large output '.repeat(100) // ~1.3KB const response = { stdout: largeOutput, stderr: '', exitCode: 0, executionTime: 100, } // Measure save time const startTime = performance.now() await manager.saveSession(sessionId, request, response) const endTime = performance.now() const duration = endTime - startTime // Verify save time is less than 500ms even with large data (relaxed from 100ms for CI stability) expect(duration).toBeLessThan(500) }) it('should save session with existing history in less than 100ms', async () => { const manager = new SessionManager(sessionConfig) const sessionId = 'perf-save-append' // First save const request1 = { agent: 'rule-advisor', prompt: 'First prompt', } const response1 = { stdout: 'First output', stderr: '', exitCode: 0, executionTime: 100, } await manager.saveSession(sessionId, request1, response1) // Measure second save time (appending to history) const request2 = { agent: 'rule-advisor', prompt: 'Second prompt', } const response2 = { stdout: 'Second output', stderr: '', exitCode: 0, executionTime: 100, } const startTime = performance.now() await manager.saveSession(sessionId, request2, response2) const endTime = performance.now() const duration = endTime - startTime // Verify save time is less than 500ms when appending (relaxed from 100ms for CI stability) expect(duration).toBeLessThan(500) }) }) /** * Performance Criterion 2: Session load time < 100ms */ describe('Session load performance', () => { it('should load session in less than 100ms', async () => { const manager = new SessionManager(sessionConfig) const sessionId = 'perf-load-test' const request = { agent: 'rule-advisor', prompt: 'Load performance test', } const response = { stdout: 'Load performance output', stderr: '', exitCode: 0, executionTime: 100, } // First save a session await manager.saveSession(sessionId, request, response) // Measure load time const startTime = performance.now() const loadedSession = await manager.loadSession(sessionId, 'rule-advisor') const endTime = performance.now() const duration = endTime - startTime // Verify load time is less than 500ms (relaxed from 100ms for CI stability) expect(duration).toBeLessThan(500) expect(loadedSession).not.toBeNull() }) it('should load large session data in less than 100ms', async () => { const manager = new SessionManager(sessionConfig) const sessionId = 'perf-load-large' // Create multiple history entries with large data const largePrompt = 'Large prompt '.repeat(100) const largeOutput = 'Large output '.repeat(100) for (let i = 0; i < 10; i++) { const request = { agent: 'rule-advisor', prompt: `${largePrompt} - ${i}`, } const response = { stdout: `${largeOutput} - ${i}`, stderr: '', exitCode: 0, executionTime: 100 + i, } await manager.saveSession(sessionId, request, response) } // Measure load time const startTime = performance.now() const loadedSession = await manager.loadSession(sessionId, 'rule-advisor') const endTime = performance.now() const duration = endTime - startTime // Verify load time is less than 100ms even with large data expect(duration).toBeLessThan(100) expect(loadedSession).not.toBeNull() expect(loadedSession?.history.length).toBeGreaterThanOrEqual(10) }) it('should return null quickly when session does not exist', async () => { const manager = new SessionManager(sessionConfig) const nonExistentSessionId = 'non-existent-perf-test' // Measure load time for non-existent session const startTime = performance.now() const loadedSession = await manager.loadSession(nonExistentSessionId, 'rule-advisor') const endTime = performance.now() const duration = endTime - startTime // Verify load time is less than 100ms even for non-existent session expect(duration).toBeLessThan(100) expect(loadedSession).toBeNull() }) }) /** * Performance Criterion 3: 1000 session management without degradation */ describe('Large-scale session management', () => { it('should handle 1000 sessions without performance degradation', async () => { const manager = new SessionManager(sessionConfig) const sessionCount = 1000 // Create 1000 sessions const createStartTime = performance.now() const sessionIds: string[] = [] for (let i = 0; i < sessionCount; i++) { const sessionId = `perf-scale-test-${i}` sessionIds.push(sessionId) const request = { agent: 'rule-advisor', prompt: `Test prompt ${i}`, } const response = { stdout: `Test output ${i}`, stderr: '', exitCode: 0, executionTime: 100, } await manager.saveSession(sessionId, request, response) } const createEndTime = performance.now() const createDuration = createEndTime - createStartTime // Verify creation time is reasonable (average < 100ms per session) const avgCreateTime = createDuration / sessionCount expect(avgCreateTime).toBeLessThan(100) // Test loading performance with many files const loadStartTime = performance.now() const loadedSession = await manager.loadSession( sessionIds[sessionCount - 1] || '', 'rule-advisor' ) const loadEndTime = performance.now() const loadDuration = loadEndTime - loadStartTime // Verify load time is still less than 100ms even with 1000 files expect(loadDuration).toBeLessThan(100) expect(loadedSession).not.toBeNull() }, 120000) // Increase timeout for this test to 120 seconds it('should load session quickly even with many files in directory', async () => { const manager = new SessionManager(sessionConfig) // Create 100 session files (reduced from 1000 for faster test) for (let i = 0; i < 100; i++) { const sessionId = `perf-many-files-${i}` const request = { agent: 'rule-advisor', prompt: `Test prompt ${i}`, } const response = { stdout: `Test output ${i}`, stderr: '', exitCode: 0, executionTime: 100, } await manager.saveSession(sessionId, request, response) } // Measure load time for a specific session const targetSessionId = 'perf-many-files-50' const startTime = performance.now() const loadedSession = await manager.loadSession(targetSessionId, 'rule-advisor') const endTime = performance.now() const duration = endTime - startTime // Verify load time is less than 100ms even with many files expect(duration).toBeLessThan(100) expect(loadedSession).not.toBeNull() }, 30000) // Increase timeout to 30 seconds }) /** * Cleanup performance test */ describe('Cleanup performance', () => { it('should cleanup old sessions without blocking', async () => { const manager = new SessionManager(sessionConfig) // Create multiple old files const oldFileCount = 50 for (let i = 0; i < oldFileCount; i++) { const oldFileName = `old-session-${i}_rule-advisor_${Date.now() + i}.json` const oldFilePath = path.join(testSessionDir, oldFileName) await fs.writeFile(oldFilePath, JSON.stringify({ test: 'data' }), 'utf-8') // Set file modification time to 8 days ago const eightDaysAgo = new Date() eightDaysAgo.setDate(eightDaysAgo.getDate() - 8) await fs.utimes(oldFilePath, eightDaysAgo, eightDaysAgo) } // Measure cleanup time const startTime = performance.now() await manager.cleanupOldSessions() const endTime = performance.now() const duration = endTime - startTime // Verify cleanup completes in reasonable time (< 1 second for 50 files) expect(duration).toBeLessThan(1000) // Verify all old files were deleted const files = await fs.readdir(testSessionDir) expect(files.length).toBe(0) }) }) /** * Concurrent operation performance test */ describe('Concurrent operations', () => { it('should handle concurrent save operations efficiently', async () => { const manager = new SessionManager(sessionConfig) const concurrentCount = 10 // Create concurrent save operations const savePromises = [] const startTime = performance.now() for (let i = 0; i < concurrentCount; i++) { const sessionId = `concurrent-save-${i}` const request = { agent: 'rule-advisor', prompt: `Concurrent prompt ${i}`, } const response = { stdout: `Concurrent output ${i}`, stderr: '', exitCode: 0, executionTime: 100, } savePromises.push(manager.saveSession(sessionId, request, response)) } // Wait for all operations to complete await Promise.all(savePromises) const endTime = performance.now() const duration = endTime - startTime // Verify concurrent operations complete in reasonable time // Average should be much less than sequential (< 50ms per operation with concurrency) const avgTime = duration / concurrentCount expect(avgTime).toBeLessThan(50) // Verify all files were created const files = await fs.readdir(testSessionDir) expect(files.length).toBe(concurrentCount) }) it('should handle concurrent load operations efficiently', async () => { const manager = new SessionManager(sessionConfig) const concurrentCount = 10 // First, create sessions to load for (let i = 0; i < concurrentCount; i++) { const sessionId = `concurrent-load-${i}` const request = { agent: 'rule-advisor', prompt: `Load prompt ${i}`, } const response = { stdout: `Load output ${i}`, stderr: '', exitCode: 0, executionTime: 100, } await manager.saveSession(sessionId, request, response) } // Measure concurrent load time const loadPromises = [] const startTime = performance.now() for (let i = 0; i < concurrentCount; i++) { const sessionId = `concurrent-load-${i}` loadPromises.push(manager.loadSession(sessionId, 'rule-advisor')) } const results = await Promise.all(loadPromises) const endTime = performance.now() const duration = endTime - startTime // Verify concurrent loads complete efficiently const avgTime = duration / concurrentCount expect(avgTime).toBeLessThan(50) // Verify all sessions were loaded expect(results.every((result) => result !== null)).toBe(true) }) }) })