claude-mycelium 2.0.0 → 2.2.0

package/tests/task/acceptance.test.ts

@@ -0,0 +1,411 @@
+/**
+ * Tests for Acceptance Criteria Validation
+ * Validates acceptance criteria checking functionality
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  validateAcceptance,
+  checkFileExists,
+  runTests,
+  generateDefaultCriteria,
+  canCompleteTask,
+} from '../../src/task/acceptance.js';
+import { Task, AcceptanceCriterion, TaskPlan } from '../../src/types/index.js';
+import * as fileUtils from '../../src/utils/file-utils.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+// Mock dependencies
+vi.mock('../../src/utils/file-utils.js');
+
+// Mock child_process exec
+vi.mock('child_process', async () => {
+  const actual = await vi.importActual<typeof import('child_process')>('child_process');
+  return {
+    ...actual,
+    exec: vi.fn(),
+  };
+});
+
+vi.mock('util', async () => {
+  const actual = await vi.importActual<typeof import('util')>('util');
+  return {
+    ...actual,
+    promisify: (fn: any) => fn,
+  };
+});
+
+describe('Acceptance Criteria Validation', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('validateAcceptance', () => {
+    it('should validate all criteria and return true if all met', async () => {
+      const task: Task = {
+        id: 'test-123',
+        description: 'Test',
+        status: 'validating',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [
+          {
+            description: 'File exists',
+            type: 'file_exists',
+            check: 'src/test.ts',
+            met: false,
+          },
+          {
+            description: 'Tests pass',
+            type: 'test_passes',
+            check: 'src/test.test.ts',
+            met: false,
+          },
+        ],
+        steps_completed: 2,
+        steps_total: 2,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      vi.mocked(fileUtils.fileExists).mockReturnValue(true);
+      vi.mocked(exec as any).mockImplementation((cmd: string, opts: any) => {
+        return Promise.resolve({ stdout: 'PASSED', stderr: '' });
+      });
+
+      const allMet = await validateAcceptance(task);
+
+      expect(allMet).toBe(true);
+      expect(task.acceptance_criteria[0].met).toBe(true);
+      expect(task.acceptance_criteria[1].met).toBe(true);
+    });
+
+    it('should return false if any criterion not met', async () => {
+      const task: Task = {
+        id: 'test-456',
+        description: 'Test',
+        status: 'validating',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [
+          {
+            description: 'File exists',
+            type: 'file_exists',
+            check: 'src/missing.ts',
+            met: false,
+          },
+        ],
+        steps_completed: 1,
+        steps_total: 1,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      vi.mocked(fileUtils.fileExists).mockReturnValue(false);
+
+      const allMet = await validateAcceptance(task);
+
+      expect(allMet).toBe(false);
+      expect(task.acceptance_criteria[0].met).toBe(false);
+    });
+
+    it('should handle mixed results', async () => {
+      const task: Task = {
+        id: 'test-789',
+        description: 'Test',
+        status: 'validating',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [
+          {
+            description: 'File exists',
+            type: 'file_exists',
+            check: 'src/test.ts',
+            met: false,
+          },
+          {
+            description: 'Another file exists',
+            type: 'file_exists',
+            check: 'src/missing.ts',
+            met: false,
+          },
+        ],
+        steps_completed: 2,
+        steps_total: 2,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      vi.mocked(fileUtils.fileExists)
+        .mockReturnValueOnce(true)
+        .mockReturnValueOnce(false);
+
+      const allMet = await validateAcceptance(task);
+
+      expect(allMet).toBe(false);
+      expect(task.acceptance_criteria[0].met).toBe(true);
+      expect(task.acceptance_criteria[1].met).toBe(false);
+    });
+  });
+
+  describe('checkFileExists', () => {
+    it('should return true if file exists', async () => {
+      vi.mocked(fileUtils.fileExists).mockReturnValue(true);
+
+      const exists = await checkFileExists('src/test.ts');
+
+      expect(exists).toBe(true);
+    });
+
+    it('should return false if file does not exist', async () => {
+      vi.mocked(fileUtils.fileExists).mockReturnValue(false);
+
+      const exists = await checkFileExists('src/missing.ts');
+
+      expect(exists).toBe(false);
+    });
+  });
+
+  describe('runTests', () => {
+    it('should return true if tests pass', async () => {
+      vi.mocked(exec as any).mockImplementation(() => {
+        return Promise.resolve({ stdout: 'Test passed\nPASSED', stderr: '' });
+      });
+
+      const passed = await runTests('src/test.test.ts');
+
+      expect(passed).toBe(true);
+    });
+
+    it('should return false if tests fail', async () => {
+      vi.mocked(exec as any).mockImplementation(() => {
+        return Promise.resolve({ stdout: 'Test FAILED\n1 failed', stderr: '' });
+      });
+
+      const passed = await runTests('src/test.test.ts');
+
+      expect(passed).toBe(false);
+    });
+
+    it('should return false on error', async () => {
+      vi.mocked(exec as any).mockImplementation(() => {
+        return Promise.reject(new Error('Command failed'));
+      });
+
+      const passed = await runTests('src/test.test.ts');
+
+      expect(passed).toBe(false);
+    });
+  });
+
+  describe('generateDefaultCriteria', () => {
+    it('should generate criteria for created files', () => {
+      const plan: TaskPlan = {
+        summary: 'Test plan',
+        steps: [
+          {
+            order: 1,
+            description: 'Create file',
+            target_file: 'src/new.ts',
+            mode: 'create',
+            depends_on: [],
+            completed: false,
+          },
+          {
+            order: 2,
+            description: 'Create test',
+            target_file: 'src/new.test.ts',
+            mode: 'create',
+            depends_on: [1],
+            completed: false,
+          },
+        ],
+        estimated_complexity: 'small',
+        risks: [],
+      };
+
+      const task: Task = {
+        id: 'test-123',
+        description: 'Test',
+        status: 'pending',
+        created_at: new Date().toISOString(),
+        plan,
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 2,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      const criteria = generateDefaultCriteria(task);
+
+      // Should have file_exists for both files
+      expect(criteria.filter(c => c.type === 'file_exists')).toHaveLength(2);
+      // Should have test_passes for test file
+      expect(criteria.filter(c => c.type === 'test_passes')).toHaveLength(1);
+      // Should have lint check for implementation file
+      expect(criteria.filter(c => c.type === 'no_lint_errors')).toHaveLength(1);
+    });
+
+    it('should generate lint criteria for modified files', () => {
+      const plan: TaskPlan = {
+        summary: 'Test plan',
+        steps: [
+          {
+            order: 1,
+            description: 'Fix errors',
+            target_file: 'src/existing.ts',
+            mode: 'error_reducer',
+            depends_on: [],
+            completed: false,
+          },
+        ],
+        estimated_complexity: 'small',
+        risks: [],
+      };
+
+      const task: Task = {
+        id: 'test-456',
+        description: 'Test',
+        status: 'pending',
+        created_at: new Date().toISOString(),
+        plan,
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 1,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      const criteria = generateDefaultCriteria(task);
+
+      // Should have lint check
+      expect(criteria.filter(c => c.type === 'no_lint_errors')).toHaveLength(1);
+    });
+
+    it('should not generate criteria for test files lint', () => {
+      const plan: TaskPlan = {
+        summary: 'Test plan',
+        steps: [
+          {
+            order: 1,
+            description: 'Create test',
+            target_file: 'src/test.test.ts',
+            mode: 'create',
+            depends_on: [],
+            completed: false,
+          },
+        ],
+        estimated_complexity: 'small',
+        risks: [],
+      };
+
+      const task: Task = {
+        id: 'test-789',
+        description: 'Test',
+        status: 'pending',
+        created_at: new Date().toISOString(),
+        plan,
+        acceptance_criteria: [],
+        steps_completed: 0,
+        steps_total: 1,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      const criteria = generateDefaultCriteria(task);
+
+      // Should not have lint check for test file
+      const lintCriteria = criteria.filter(c => c.type === 'no_lint_errors');
+      expect(lintCriteria).toHaveLength(0);
+    });
+  });
+
+  describe('canCompleteTask', () => {
+    it('should return true if all steps and criteria met', () => {
+      const task: Task = {
+        id: 'test-123',
+        description: 'Test',
+        status: 'validating',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [
+          {
+            description: 'File exists',
+            type: 'file_exists',
+            check: 'src/test.ts',
+            met: true,
+          },
+        ],
+        steps_completed: 2,
+        steps_total: 2,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      expect(canCompleteTask(task)).toBe(true);
+    });
+
+    it('should return false if steps not completed', () => {
+      const task: Task = {
+        id: 'test-456',
+        description: 'Test',
+        status: 'in_progress',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [],
+        steps_completed: 1,
+        steps_total: 2,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      expect(canCompleteTask(task)).toBe(false);
+    });
+
+    it('should return false if criteria not met', () => {
+      const task: Task = {
+        id: 'test-789',
+        description: 'Test',
+        status: 'validating',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [
+          {
+            description: 'File exists',
+            type: 'file_exists',
+            check: 'src/test.ts',
+            met: false,
+          },
+        ],
+        steps_completed: 2,
+        steps_total: 2,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      expect(canCompleteTask(task)).toBe(false);
+    });
+
+    it('should return true if no criteria and all steps done', () => {
+      const task: Task = {
+        id: 'test-999',
+        description: 'Test',
+        status: 'validating',
+        created_at: new Date().toISOString(),
+        acceptance_criteria: [],
+        steps_completed: 3,
+        steps_total: 3,
+        files_created: [],
+        files_modified: [],
+        traces: [],
+      };
+
+      expect(canCompleteTask(task)).toBe(true);
+    });
+  });
+});