vibeman 0.0.5 → 0.0.7

package/dist/runtime/api/persistence/execution-log-persistence.test.js

@@ -1,170 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { ExecutionLogPersistence } from './execution-log-persistence.js';
-const TEST_DATA_DIR = path.resolve(process.cwd(), '.test-execution-logs');
-// Mock getVibeDir to return test directory
-vi.mock('../lib/server/project-root', () => ({
-    getVibeDir: () => TEST_DATA_DIR,
-}));
-describe('ExecutionLogPersistence', () => {
-    let persistence;
-    beforeEach(() => {
-        persistence = new ExecutionLogPersistence();
-    });
-    afterEach(async () => {
-        // Clean up test data
-        try {
-            await fs.rm(TEST_DATA_DIR, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    });
-    it('should create execution log directory and files', async () => {
-        const mockExecution = {
-            id: 'exec_test_001',
-            taskId: 'TASK-001',
-            status: 'pending',
-            startTime: '2024-09-04T12:00:00.000Z',
-            logs: [],
-            workingDirectory: '/test/dir',
-        };
-        await persistence.startExecution(mockExecution, 'workflow_123');
-        // Check that files were created
-        const executions = await persistence.listExecutions();
-        expect(executions).toHaveLength(1);
-        expect(executions[0].executionId).toBe('exec_test_001');
-        expect(executions[0].taskId).toBe('TASK-001');
-        expect(executions[0].workflowId).toBe('workflow_123');
-    });
-    it('should log messages and read them back', async () => {
-        const mockExecution = {
-            id: 'exec_test_002',
-            taskId: 'TASK-002',
-            status: 'running',
-            startTime: '2024-09-04T12:00:00.000Z',
-            logs: [],
-            workingDirectory: '/test/dir',
-        };
-        await persistence.startExecution(mockExecution);
-        await persistence.logMessage('exec_test_002', 'Starting task execution');
-        await persistence.logMessage('exec_test_002', 'Processing files', 'info', { fileCount: 5 });
-        await persistence.completeExecution('exec_test_002', 'completed');
-        const { metadata, logs } = await persistence.readExecutionLogs('exec_test_002');
-        expect(metadata?.executionId).toBe('exec_test_002');
-        expect(metadata?.status).toBe('completed');
-        expect(metadata?.endTime).toBeDefined();
-        expect(logs.length).toBeGreaterThanOrEqual(3); // Initial + 2 custom + completion
-        expect(logs.some((log) => log.message.includes('Starting task execution'))).toBe(true);
-        expect(logs.some((log) => log.message.includes('Processing files'))).toBe(true);
-        expect(logs.some((log) => log.data?.fileCount === 5)).toBe(true);
-    });
-    it('should handle execution failure', async () => {
-        const mockExecution = {
-            id: 'exec_test_003',
-            taskId: 'TASK-003',
-            status: 'running',
-            startTime: '2024-09-04T12:00:00.000Z',
-            logs: [],
-            workingDirectory: '/test/dir',
-        };
-        await persistence.startExecution(mockExecution);
-        await persistence.logMessage('exec_test_003', 'Task execution failed', 'error');
-        await persistence.completeExecution('exec_test_003', 'failed', 'Something went wrong');
-        const { metadata, logs } = await persistence.readExecutionLogs('exec_test_003');
-        expect(metadata?.status).toBe('failed');
-        expect(metadata?.error).toBe('Something went wrong');
-        expect(logs.some((log) => log.level === 'error')).toBe(true);
-    });
-    it('should list and cleanup old executions', async () => {
-        // Create multiple executions
-        const executions = [
-            { id: 'exec_old_001', taskId: 'TASK-OLD1', status: 'completed' },
-            { id: 'exec_old_002', taskId: 'TASK-OLD2', status: 'failed' },
-            { id: 'exec_new_001', taskId: 'TASK-NEW1', status: 'running' },
-        ];
-        for (const exec of executions) {
-            const mockExecution = {
-                id: exec.id,
-                taskId: exec.taskId,
-                status: exec.status,
-                startTime: '2024-09-04T12:00:00.000Z',
-                logs: [],
-                workingDirectory: '/test/dir',
-            };
-            await persistence.startExecution(mockExecution);
-            if (exec.status !== 'running') {
-                await persistence.completeExecution(exec.id, exec.status);
-            }
-        }
-        // Should have 3 executions
-        let allExecutions = await persistence.listExecutions();
-        expect(allExecutions).toHaveLength(3);
-        // Cleanup old executions (use very short age for testing)
-        await persistence.cleanupOldLogs(0.001); // ~0.0864 seconds
-        // Wait a moment for the timeout to pass
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        // Try cleanup again
-        await persistence.cleanupOldLogs(0.001);
-        // Should have cleaned up completed/failed executions
-        allExecutions = await persistence.listExecutions();
-        expect(allExecutions.length).toBeLessThanOrEqual(3); // Some may be cleaned up
-    });
-    it('should remove executions by task ID', async () => {
-        // Create executions for different tasks
-        const executions = [
-            { id: 'exec_task1_001', taskId: 'TASK-REMOVE' },
-            { id: 'exec_task1_002', taskId: 'TASK-REMOVE' },
-            { id: 'exec_task2_001', taskId: 'TASK-KEEP' },
-        ];
-        for (const exec of executions) {
-            const mockExecution = {
-                id: exec.id,
-                taskId: exec.taskId,
-                status: 'completed',
-                startTime: '2024-09-04T12:00:00.000Z',
-                logs: [],
-                workingDirectory: '/test/dir',
-            };
-            await persistence.startExecution(mockExecution);
-            await persistence.completeExecution(exec.id, 'completed');
-        }
-        // Should have 3 executions
-        let allExecutions = await persistence.listExecutions();
-        expect(allExecutions).toHaveLength(3);
-        // Remove executions for TASK-REMOVE
-        const removedCount = await persistence.removeExecutionsByTask('TASK-REMOVE');
-        expect(removedCount).toBe(2);
-        // Should have 1 execution left
-        allExecutions = await persistence.listExecutions();
-        expect(allExecutions).toHaveLength(1);
-        expect(allExecutions[0].taskId).toBe('TASK-KEEP');
-    });
-    it('should provide execution statistics', async () => {
-        // Create executions with different statuses
-        const executions = [
-            { id: 'exec_stat_001', status: 'completed' },
-            { id: 'exec_stat_002', status: 'failed' },
-            { id: 'exec_stat_003', status: 'completed' },
-        ];
-        for (const exec of executions) {
-            const mockExecution = {
-                id: exec.id,
-                taskId: 'TASK-STATS',
-                status: exec.status,
-                startTime: '2024-09-04T12:00:00.000Z',
-                logs: [],
-                workingDirectory: '/test/dir',
-            };
-            await persistence.startExecution(mockExecution);
-            await persistence.completeExecution(exec.id, exec.status);
-        }
-        const stats = await persistence.getStats();
-        expect(stats.total).toBe(3);
-        expect(stats.byStatus.completed).toBe(2);
-        expect(stats.byStatus.failed).toBe(1);
-        expect(stats.oldestExecution).toBeDefined();
-        expect(stats.newestExecution).toBeDefined();
-    });
-});