claude-task-master/tests/unit/task-manager.test.js

/**
 * Task Manager module tests
 */

import { jest } from '@jest/globals';

// Mock implementations
const mockReadFileSync = jest.fn();
const mockExistsSync = jest.fn();
const mockMkdirSync = jest.fn();
const mockDirname = jest.fn();
const mockCallClaude = jest.fn();
const mockWriteJSON = jest.fn();
const mockGenerateTaskFiles = jest.fn();

// Mock fs module
jest.mock('fs', () => ({
  readFileSync: mockReadFileSync,
  existsSync: mockExistsSync,
  mkdirSync: mockMkdirSync
}));

// Mock path module
jest.mock('path', () => ({
  dirname: mockDirname
}));

// Mock AI services
jest.mock('../../scripts/modules/ai-services.js', () => ({
  callClaude: mockCallClaude
}));

// Mock utils
jest.mock('../../scripts/modules/utils.js', () => ({
  writeJSON: mockWriteJSON,
  log: jest.fn()
}));

// Create a simplified version of parsePRD for testing
const testParsePRD = async (prdPath, outputPath, numTasks) => {
  try {
    const prdContent = mockReadFileSync(prdPath, 'utf8');
    const tasks = await mockCallClaude(prdContent, prdPath, numTasks);
    const dir = mockDirname(outputPath);
    
    if (!mockExistsSync(dir)) {
      mockMkdirSync(dir, { recursive: true });
    }
    
    mockWriteJSON(outputPath, tasks);
    await mockGenerateTaskFiles(outputPath, dir);
    
    return tasks;
  } catch (error) {
    console.error(`Error parsing PRD: ${error.message}`);
    process.exit(1);
  }
};

// Import after mocks
import { findNextTask } from '../../scripts/modules/task-manager.js';
import { sampleClaudeResponse } from '../fixtures/sample-claude-response.js';

describe('Task Manager Module', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });

  describe('findNextTask function', () => {
    test('should return the highest priority task with all dependencies satisfied', () => {
      const tasks = [
        {
          id: 1,
          title: 'Setup Project',
          status: 'done',
          dependencies: [],
          priority: 'high'
        },
        {
          id: 2,
          title: 'Implement Core Features',
          status: 'pending',
          dependencies: [1],
          priority: 'high'
        },
        {
          id: 3,
          title: 'Create Documentation',
          status: 'pending',
          dependencies: [1],
          priority: 'medium'
        },
        {
          id: 4,
          title: 'Deploy Application',
          status: 'pending',
          dependencies: [2, 3],
          priority: 'high'
        }
      ];

      const nextTask = findNextTask(tasks);
      
      expect(nextTask).toBeDefined();
      expect(nextTask.id).toBe(2);
      expect(nextTask.title).toBe('Implement Core Features');
    });

    test('should prioritize by priority level when dependencies are equal', () => {
      const tasks = [
        {
          id: 1,
          title: 'Setup Project',
          status: 'done',
          dependencies: [],
          priority: 'high'
        },
        {
          id: 2,
          title: 'Low Priority Task',
          status: 'pending',
          dependencies: [1],
          priority: 'low'
        },
        {
          id: 3,
          title: 'Medium Priority Task',
          status: 'pending',
          dependencies: [1],
          priority: 'medium'
        },
        {
          id: 4,
          title: 'High Priority Task',
          status: 'pending',
          dependencies: [1],
          priority: 'high'
        }
      ];

      const nextTask = findNextTask(tasks);
      
      expect(nextTask.id).toBe(4);
      expect(nextTask.priority).toBe('high');
    });

    test('should return null when all tasks are completed', () => {
      const tasks = [
        {
          id: 1,
          title: 'Setup Project',
          status: 'done',
          dependencies: [],
          priority: 'high'
        },
        {
          id: 2,
          title: 'Implement Features',
          status: 'done',
          dependencies: [1],
          priority: 'high'
        }
      ];

      const nextTask = findNextTask(tasks);
      
      expect(nextTask).toBeNull();
    });

    test('should return null when all pending tasks have unsatisfied dependencies', () => {
      const tasks = [
        {
          id: 1,
          title: 'Setup Project',
          status: 'pending',
          dependencies: [2],
          priority: 'high'
        },
        {
          id: 2,
          title: 'Implement Features',
          status: 'pending',
          dependencies: [1],
          priority: 'high'
        }
      ];

      const nextTask = findNextTask(tasks);
      
      expect(nextTask).toBeNull();
    });

    test('should handle empty tasks array', () => {
      const nextTask = findNextTask([]);
      
      expect(nextTask).toBeNull();
    });
  });

  // Skipped tests for analyzeTaskComplexity
  describe.skip('analyzeTaskComplexity function', () => {
    // These tests are skipped because they require complex mocking
    // but document what should be tested
    
    test('should handle valid JSON response from LLM', async () => {
      // This test would verify that:
      // 1. The function properly calls the AI model
      // 2. It correctly parses a valid JSON response
      // 3. It generates a properly formatted complexity report
      // 4. The report includes all analyzed tasks with their complexity scores
      expect(true).toBe(true);
    });
    
    test('should handle and fix malformed JSON with unterminated strings', async () => {
      // This test would verify that:
      // 1. The function can handle JSON with unterminated strings
      // 2. It applies regex fixes to repair the malformed JSON
      // 3. It still produces a valid report despite receiving bad JSON
      expect(true).toBe(true);
    });
    
    test('should handle missing tasks in the response', async () => {
      // This test would verify that:
      // 1. When the AI response is missing some tasks
      // 2. The function detects the missing tasks
      // 3. It attempts to analyze just those missing tasks
      // 4. The final report includes all tasks that could be analyzed
      expect(true).toBe(true);
    });
    
    test('should use Perplexity research when research flag is set', async () => {
      // This test would verify that:
      // 1. The function uses Perplexity API when the research flag is set
      // 2. It correctly formats the prompt for Perplexity
      // 3. It properly handles the Perplexity response
      expect(true).toBe(true);
    });
    
    test('should fall back to Claude when Perplexity is unavailable', async () => {
      // This test would verify that:
      // 1. The function falls back to Claude when Perplexity API is not available
      // 2. It handles the fallback gracefully
      // 3. It still produces a valid report using Claude
      expect(true).toBe(true);
    });
    
    test('should process multiple tasks in parallel', async () => {
      // This test would verify that:
      // 1. The function can analyze multiple tasks efficiently
      // 2. It correctly aggregates the results
      expect(true).toBe(true);
    });
  });

  describe('parsePRD function', () => {
    // Mock the sample PRD content
    const samplePRDContent = '# Sample PRD for Testing';
    
    beforeEach(() => {
      // Reset all mocks
      jest.clearAllMocks();
      
      // Set up mocks for fs, path and other modules
      mockReadFileSync.mockReturnValue(samplePRDContent);
      mockExistsSync.mockReturnValue(true);
      mockDirname.mockReturnValue('tasks');
      mockCallClaude.mockResolvedValue(sampleClaudeResponse);
      mockGenerateTaskFiles.mockResolvedValue(undefined);
    });
    
    test('should parse a PRD file and generate tasks', async () => {
      // Call the test version of parsePRD
      await testParsePRD('path/to/prd.txt', 'tasks/tasks.json', 3);
      
      // Verify fs.readFileSync was called with the correct arguments
      expect(mockReadFileSync).toHaveBeenCalledWith('path/to/prd.txt', 'utf8');
      
      // Verify callClaude was called with the correct arguments
      expect(mockCallClaude).toHaveBeenCalledWith(samplePRDContent, 'path/to/prd.txt', 3);
      
      // Verify directory check
      expect(mockExistsSync).toHaveBeenCalledWith('tasks');
      
      // Verify writeJSON was called with the correct arguments
      expect(mockWriteJSON).toHaveBeenCalledWith('tasks/tasks.json', sampleClaudeResponse);
      
      // Verify generateTaskFiles was called
      expect(mockGenerateTaskFiles).toHaveBeenCalledWith('tasks/tasks.json', 'tasks');
    });
    
    test('should create the tasks directory if it does not exist', async () => {
      // Mock existsSync to return false to simulate directory doesn't exist
      mockExistsSync.mockReturnValueOnce(false);
      
      // Call the function
      await testParsePRD('path/to/prd.txt', 'tasks/tasks.json', 3);
      
      // Verify mkdir was called
      expect(mockMkdirSync).toHaveBeenCalledWith('tasks', { recursive: true });
    });
    
    test('should handle errors in the PRD parsing process', async () => {
      // Mock an error in callClaude
      const testError = new Error('Test error in Claude API call');
      mockCallClaude.mockRejectedValueOnce(testError);
      
      // Mock console.error and process.exit
      const mockConsoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
      const mockProcessExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
      
      // Call the function
      await testParsePRD('path/to/prd.txt', 'tasks/tasks.json', 3);
      
      // Verify error handling
      expect(mockConsoleError).toHaveBeenCalled();
      expect(mockProcessExit).toHaveBeenCalledWith(1);
      
      // Restore mocks
      mockConsoleError.mockRestore();
      mockProcessExit.mockRestore();
    });
    
    test('should generate individual task files after creating tasks.json', async () => {
      // Call the function
      await testParsePRD('path/to/prd.txt', 'tasks/tasks.json', 3);
      
      // Verify generateTaskFiles was called
      expect(mockGenerateTaskFiles).toHaveBeenCalledWith('tasks/tasks.json', 'tasks');
    });
  });
  
  describe.skip('updateTasks function', () => {
    test('should update tasks based on new context', async () => {
      // This test would verify that:
      // 1. The function reads the tasks file correctly
      // 2. It filters tasks with ID >= fromId and not 'done'
      // 3. It properly calls the AI model with the correct prompt
      // 4. It updates the tasks with the AI response
      // 5. It writes the updated tasks back to the file
      expect(true).toBe(true);
    });
    
    test('should handle streaming responses from Claude API', async () => {
      // This test would verify that:
      // 1. The function correctly handles streaming API calls
      // 2. It processes the stream data properly
      // 3. It combines the chunks into a complete response
      expect(true).toBe(true);
    });
    
    test('should use Perplexity AI when research flag is set', async () => {
      // This test would verify that:
      // 1. The function uses Perplexity when the research flag is set
      // 2. It formats the prompt correctly for Perplexity
      // 3. It properly processes the Perplexity response
      expect(true).toBe(true);
    });
    
    test('should handle no tasks to update', async () => {
      // This test would verify that:
      // 1. The function handles the case when no tasks need updating
      // 2. It provides appropriate feedback to the user
      expect(true).toBe(true);
    });
    
    test('should handle errors during the update process', async () => {
      // This test would verify that:
      // 1. The function handles errors in the AI API calls
      // 2. It provides appropriate error messages
      // 3. It exits gracefully
      expect(true).toBe(true);
    });
  });
  
  describe.skip('generateTaskFiles function', () => {
    test('should generate task files from tasks.json', () => {
      // This test would verify that:
      // 1. The function reads the tasks file correctly
      // 2. It creates the output directory if needed
      // 3. It generates one file per task with correct format
      // 4. It handles subtasks properly in the generated files
      expect(true).toBe(true);
    });
    
    test('should format dependencies with status indicators', () => {
      // This test would verify that:
      // 1. The function formats task dependencies correctly
      // 2. It includes status indicators for each dependency
      expect(true).toBe(true);
    });
    
    test('should handle tasks with no subtasks', () => {
      // This test would verify that:
      // 1. The function handles tasks without subtasks properly
      expect(true).toBe(true);
    });
    
    test('should handle empty tasks array', () => {
      // This test would verify that:
      // 1. The function handles an empty tasks array gracefully
      expect(true).toBe(true);
    });
    
    test('should validate dependencies before generating files', () => {
      // This test would verify that:
      // 1. The function validates dependencies before generating files
      // 2. It fixes invalid dependencies as needed
      expect(true).toBe(true);
    });
  });
  
  describe.skip('setTaskStatus function', () => {
    test('should update task status in tasks.json', async () => {
      // This test would verify that:
      // 1. The function reads the tasks file correctly
      // 2. It finds the target task by ID
      // 3. It updates the task status
      // 4. It writes the updated tasks back to the file
      expect(true).toBe(true);
    });
    
    test('should update subtask status when using dot notation', async () => {
      // This test would verify that:
      // 1. The function correctly parses the subtask ID in dot notation
      // 2. It finds the parent task and subtask
      // 3. It updates the subtask status
      expect(true).toBe(true);
    });
    
    test('should update multiple tasks when given comma-separated IDs', async () => {
      // This test would verify that:
      // 1. The function handles comma-separated task IDs
      // 2. It updates all specified tasks
      expect(true).toBe(true);
    });
    
    test('should automatically mark subtasks as done when parent is marked done', async () => {
      // This test would verify that:
      // 1. When a parent task is marked as done
      // 2. All its subtasks are also marked as done
      expect(true).toBe(true);
    });
    
    test('should suggest updating parent task when all subtasks are done', async () => {
      // This test would verify that:
      // 1. When all subtasks of a parent are marked as done
      // 2. The function suggests updating the parent task status
      expect(true).toBe(true);
    });
    
    test('should handle non-existent task ID', async () => {
      // This test would verify that:
      // 1. The function throws an error for non-existent task ID
      // 2. It provides a helpful error message
      expect(true).toBe(true);
    });
  });
  
  describe.skip('updateSingleTaskStatus function', () => {
    test('should update regular task status', async () => {
      // This test would verify that:
      // 1. The function correctly updates a regular task's status
      // 2. It handles the task data properly
      expect(true).toBe(true);
    });
    
    test('should update subtask status', async () => {
      // This test would verify that:
      // 1. The function correctly updates a subtask's status
      // 2. It finds the parent task and subtask properly
      expect(true).toBe(true);
    });
    
    test('should handle parent tasks without subtasks', async () => {
      // This test would verify that:
      // 1. The function handles attempts to update subtasks when none exist
      // 2. It throws an appropriate error
      expect(true).toBe(true);
    });
    
    test('should handle non-existent subtask ID', async () => {
      // This test would verify that:
      // 1. The function handles attempts to update non-existent subtasks
      // 2. It throws an appropriate error
      expect(true).toBe(true);
    });
  });
  
  describe.skip('listTasks function', () => {
    test('should display all tasks when no filter is provided', () => {
      // This test would verify that:
      // 1. The function reads the tasks file correctly
      // 2. It displays all tasks without filtering
      // 3. It formats the output correctly
      expect(true).toBe(true);
    });
    
    test('should filter tasks by status when filter is provided', () => {
      // This test would verify that:
      // 1. The function filters tasks by the provided status
      // 2. It only displays tasks matching the filter
      expect(true).toBe(true);
    });
    
    test('should display subtasks when withSubtasks flag is true', () => {
      // This test would verify that:
      // 1. The function displays subtasks when the flag is set
      // 2. It formats subtasks correctly in the output
      expect(true).toBe(true);
    });
    
    test('should display completion statistics', () => {
      // This test would verify that:
      // 1. The function calculates completion statistics correctly
      // 2. It displays the progress bars and percentages
      expect(true).toBe(true);
    });
    
    test('should identify and display the next task to work on', () => {
      // This test would verify that:
      // 1. The function correctly identifies the next task to work on
      // 2. It displays the next task prominently
      expect(true).toBe(true);
    });
    
    test('should handle empty tasks array', () => {
      // This test would verify that:
      // 1. The function handles an empty tasks array gracefully
      // 2. It displays an appropriate message
      expect(true).toBe(true);
    });
  });
  
  describe.skip('expandTask function', () => {
    test('should generate subtasks for a task', async () => {
      // This test would verify that:
      // 1. The function reads the tasks file correctly
      // 2. It finds the target task by ID
      // 3. It generates subtasks with unique IDs
      // 4. It adds the subtasks to the task
      // 5. It writes the updated tasks back to the file
      expect(true).toBe(true);
    });
    
    test('should use complexity report for subtask count', async () => {
      // This test would verify that:
      // 1. The function checks for a complexity report
      // 2. It uses the recommended subtask count from the report
      // 3. It uses the expansion prompt from the report
      expect(true).toBe(true);
    });
    
    test('should use Perplexity AI when research flag is set', async () => {
      // This test would verify that:
      // 1. The function uses Perplexity for research-backed generation
      // 2. It handles the Perplexity response correctly
      expect(true).toBe(true);
    });
    
    test('should append subtasks to existing ones', async () => {
      // This test would verify that:
      // 1. The function appends new subtasks to existing ones
      // 2. It generates unique subtask IDs
      expect(true).toBe(true);
    });
    
    test('should skip completed tasks', async () => {
      // This test would verify that:
      // 1. The function skips tasks marked as done or completed
      // 2. It provides appropriate feedback
      expect(true).toBe(true);
    });
    
    test('should handle errors during subtask generation', async () => {
      // This test would verify that:
      // 1. The function handles errors in the AI API calls
      // 2. It provides appropriate error messages
      // 3. It exits gracefully
      expect(true).toBe(true);
    });
  });
  
  describe.skip('expandAllTasks function', () => {
    test('should expand all pending tasks', async () => {
      // This test would verify that:
      // 1. The function identifies all pending tasks
      // 2. It expands each task with appropriate subtasks
      // 3. It writes the updated tasks back to the file
      expect(true).toBe(true);
    });
    
    test('should sort tasks by complexity when report is available', async () => {
      // This test would verify that:
      // 1. The function reads the complexity report
      // 2. It sorts tasks by complexity score
      // 3. It prioritizes high-complexity tasks
      expect(true).toBe(true);
    });
    
    test('should skip tasks with existing subtasks unless force flag is set', async () => {
      // This test would verify that:
      // 1. The function skips tasks with existing subtasks
      // 2. It processes them when force flag is set
      expect(true).toBe(true);
    });
    
    test('should use task-specific parameters from complexity report', async () => {
      // This test would verify that:
      // 1. The function uses task-specific subtask counts
      // 2. It uses task-specific expansion prompts
      expect(true).toBe(true);
    });
    
    test('should handle empty tasks array', async () => {
      // This test would verify that:
      // 1. The function handles an empty tasks array gracefully
      // 2. It displays an appropriate message
      expect(true).toBe(true);
    });
    
    test('should handle errors for individual tasks without failing the entire operation', async () => {
      // This test would verify that:
      // 1. The function continues processing tasks even if some fail
      // 2. It reports errors for individual tasks
      // 3. It completes the operation for successful tasks
      expect(true).toBe(true);
    });
  });
  
  describe.skip('clearSubtasks function', () => {
    test('should clear subtasks from a specific task', () => {
      // This test would verify that:
      // 1. The function reads the tasks file correctly
      // 2. It finds the target task by ID
      // 3. It clears the subtasks array
      // 4. It writes the updated tasks back to the file
      expect(true).toBe(true);
    });
    
    test('should clear subtasks from multiple tasks when given comma-separated IDs', () => {
      // This test would verify that:
      // 1. The function handles comma-separated task IDs
      // 2. It clears subtasks from all specified tasks
      expect(true).toBe(true);
    });
    
    test('should handle tasks with no subtasks', () => {
      // This test would verify that:
      // 1. The function handles tasks without subtasks gracefully
      // 2. It provides appropriate feedback
      expect(true).toBe(true);
    });
    
    test('should handle non-existent task IDs', () => {
      // This test would verify that:
      // 1. The function handles non-existent task IDs gracefully
      // 2. It logs appropriate error messages
      expect(true).toBe(true);
    });
    
    test('should regenerate task files after clearing subtasks', () => {
      // This test would verify that:
      // 1. The function regenerates task files after clearing subtasks
      // 2. The new files reflect the changes
      expect(true).toBe(true);
    });
  });
  
  describe.skip('addTask function', () => {
    test('should add a new task using AI', async () => {
      // This test would verify that:
      // 1. The function reads the tasks file correctly
      // 2. It determines the next available task ID
      // 3. It calls the AI model with the correct prompt
      // 4. It creates a properly structured task object
      // 5. It adds the task to the tasks array
      // 6. It writes the updated tasks back to the file
      expect(true).toBe(true);
    });
    
    test('should handle Claude streaming responses', async () => {
      // This test would verify that:
      // 1. The function correctly handles streaming API calls
      // 2. It processes the stream data properly
      // 3. It combines the chunks into a complete response
      expect(true).toBe(true);
    });
    
    test('should validate dependencies when adding a task', async () => {
      // This test would verify that:
      // 1. The function validates provided dependencies
      // 2. It removes invalid dependencies
      // 3. It logs appropriate messages
      expect(true).toBe(true);
    });
    
    test('should handle malformed AI responses', async () => {
      // This test would verify that:
      // 1. The function handles malformed JSON in AI responses
      // 2. It provides appropriate error messages
      // 3. It exits gracefully
      expect(true).toBe(true);
    });
    
    test('should use existing task context for better generation', async () => {
      // This test would verify that:
      // 1. The function uses existing tasks as context
      // 2. It provides dependency context when dependencies are specified
      // 3. It generates tasks that fit with the existing project
      expect(true).toBe(true);
    });
  });
});