vibeman 0.0.0 → 0.0.1

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

@@ -0,0 +1,170 @@
+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();
+    });
+});