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

/**
 * Commands module tests
 */

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

// Mock functions that need jest.fn methods
const mockParsePRD = jest.fn().mockResolvedValue(undefined);
const mockUpdateTaskById = jest.fn().mockResolvedValue({
	id: 2,
	title: 'Updated Task',
	description: 'Updated description'
});
const mockDisplayBanner = jest.fn();
const mockDisplayHelp = jest.fn();
const mockLog = jest.fn();

// Mock modules first
jest.mock('fs', () => ({
	existsSync: jest.fn(),
	readFileSync: jest.fn()
}));

jest.mock('path', () => ({
	join: jest.fn((dir, file) => `${dir}/${file}`)
}));

jest.mock('chalk', () => ({
	red: jest.fn((text) => text),
	blue: jest.fn((text) => text),
	green: jest.fn((text) => text),
	yellow: jest.fn((text) => text),
	white: jest.fn((text) => ({
		bold: jest.fn((text) => text)
	})),
	reset: jest.fn((text) => text)
}));

jest.mock('../../scripts/modules/ui.js', () => ({
	displayBanner: mockDisplayBanner,
	displayHelp: mockDisplayHelp
}));

jest.mock('../../scripts/modules/task-manager.js', () => ({
	parsePRD: mockParsePRD,
	updateTaskById: mockUpdateTaskById
}));

// Add this function before the mock of utils.js
/**
 * Convert camelCase to kebab-case
 * @param {string} str - String to convert
 * @returns {string} kebab-case version of the input
 */
const toKebabCase = (str) => {
	return str
		.replace(/([a-z0-9])([A-Z])/g, '$1-$2')
		.toLowerCase()
		.replace(/^-/, ''); // Remove leading hyphen if present
};

/**
 * Detect camelCase flags in command arguments
 * @param {string[]} args - Command line arguments to check
 * @returns {Array<{original: string, kebabCase: string}>} - List of flags that should be converted
 */
function detectCamelCaseFlags(args) {
	const camelCaseFlags = [];
	for (const arg of args) {
		if (arg.startsWith('--')) {
			const flagName = arg.split('=')[0].slice(2); // Remove -- and anything after =

			// Skip if it's a single word (no hyphens) or already in kebab-case
			if (!flagName.includes('-')) {
				// Check for camelCase pattern (lowercase followed by uppercase)
				if (/[a-z][A-Z]/.test(flagName)) {
					const kebabVersion = toKebabCase(flagName);
					if (kebabVersion !== flagName) {
						camelCaseFlags.push({
							original: flagName,
							kebabCase: kebabVersion
						});
					}
				}
			}
		}
	}
	return camelCaseFlags;
}

// Then update the utils.js mock to include these functions
jest.mock('../../scripts/modules/utils.js', () => ({
	CONFIG: {
		projectVersion: '1.5.0'
	},
	log: mockLog,
	toKebabCase: toKebabCase,
	detectCamelCaseFlags: detectCamelCaseFlags
}));

// Import all modules after mocking
import fs from 'fs';
import path from 'path';
import chalk from 'chalk';
import { setupCLI } from '../../scripts/modules/commands.js';

// We'll use a simplified, direct test approach instead of Commander mocking
describe('Commands Module', () => {
	// Set up spies on the mocked modules
	const mockExistsSync = jest.spyOn(fs, 'existsSync');
	const mockReadFileSync = jest.spyOn(fs, 'readFileSync');
	const mockJoin = jest.spyOn(path, 'join');
	const mockConsoleLog = jest
		.spyOn(console, 'log')
		.mockImplementation(() => {});
	const mockConsoleError = jest
		.spyOn(console, 'error')
		.mockImplementation(() => {});
	const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});

	beforeEach(() => {
		jest.clearAllMocks();
		mockExistsSync.mockReturnValue(true);
	});

	afterAll(() => {
		jest.restoreAllMocks();
	});

	describe('setupCLI function', () => {
		test('should return Commander program instance', () => {
			const program = setupCLI();
			expect(program).toBeDefined();
			expect(program.name()).toBe('dev');
		});

		test('should read version from package.json when available', () => {
			mockExistsSync.mockReturnValue(true);
			mockReadFileSync.mockReturnValue('{"version": "1.0.0"}');
			mockJoin.mockReturnValue('package.json');

			const program = setupCLI();
			const version = program._version();
			expect(mockReadFileSync).toHaveBeenCalledWith('package.json', 'utf8');
			expect(version).toBe('1.0.0');
		});

		test('should use default version when package.json is not available', () => {
			mockExistsSync.mockReturnValue(false);

			const program = setupCLI();
			const version = program._version();
			expect(mockReadFileSync).not.toHaveBeenCalled();
			expect(version).toBe('1.5.0');
		});

		test('should use default version when package.json reading throws an error', () => {
			mockExistsSync.mockReturnValue(true);
			mockReadFileSync.mockImplementation(() => {
				throw new Error('Invalid JSON');
			});

			const program = setupCLI();
			const version = program._version();
			expect(mockReadFileSync).toHaveBeenCalled();
			expect(version).toBe('1.5.0');
		});
	});

	describe('Kebab Case Validation', () => {
		test('should detect camelCase flags correctly', () => {
			const args = ['node', 'task-master', '--camelCase', '--kebab-case'];
			const camelCaseFlags = args.filter(
				(arg) =>
					arg.startsWith('--') && /[A-Z]/.test(arg) && !arg.includes('-[A-Z]')
			);
			expect(camelCaseFlags).toContain('--camelCase');
			expect(camelCaseFlags).not.toContain('--kebab-case');
		});

		test('should accept kebab-case flags correctly', () => {
			const args = ['node', 'task-master', '--kebab-case'];
			const camelCaseFlags = args.filter(
				(arg) =>
					arg.startsWith('--') && /[A-Z]/.test(arg) && !arg.includes('-[A-Z]')
			);
			expect(camelCaseFlags).toHaveLength(0);
		});
	});

	describe('parse-prd command', () => {
		// Since mocking Commander is complex, we'll test the action handler directly
		// Recreate the action handler logic based on commands.js
		async function parsePrdAction(file, options) {
			// Use input option if file argument not provided
			const inputFile = file || options.input;
			const defaultPrdPath = 'scripts/prd.txt';

			// If no input file specified, check for default PRD location
			if (!inputFile) {
				if (fs.existsSync(defaultPrdPath)) {
					console.log(chalk.blue(`Using default PRD file: ${defaultPrdPath}`));
					const numTasks = parseInt(options.numTasks, 10);
					const outputPath = options.output;

					console.log(chalk.blue(`Generating ${numTasks} tasks...`));
					await mockParsePRD(defaultPrdPath, outputPath, numTasks);
					return;
				}

				console.log(
					chalk.yellow(
						'No PRD file specified and default PRD file not found at scripts/prd.txt.'
					)
				);
				return;
			}

			const numTasks = parseInt(options.numTasks, 10);
			const outputPath = options.output;

			console.log(chalk.blue(`Parsing PRD file: ${inputFile}`));
			console.log(chalk.blue(`Generating ${numTasks} tasks...`));

			await mockParsePRD(inputFile, outputPath, numTasks);
		}

		beforeEach(() => {
			// Reset the parsePRD mock
			mockParsePRD.mockClear();
		});

		test('should use default PRD path when no arguments provided', async () => {
			// Arrange
			mockExistsSync.mockReturnValue(true);

			// Act - call the handler directly with the right params
			await parsePrdAction(undefined, {
				numTasks: '10',
				output: 'tasks/tasks.json'
			});

			// Assert
			expect(mockExistsSync).toHaveBeenCalledWith('scripts/prd.txt');
			expect(mockConsoleLog).toHaveBeenCalledWith(
				expect.stringContaining('Using default PRD file')
			);
			expect(mockParsePRD).toHaveBeenCalledWith(
				'scripts/prd.txt',
				'tasks/tasks.json',
				10 // Default value from command definition
			);
		});

		test('should display help when no arguments and no default PRD exists', async () => {
			// Arrange
			mockExistsSync.mockReturnValue(false);

			// Act - call the handler directly with the right params
			await parsePrdAction(undefined, {
				numTasks: '10',
				output: 'tasks/tasks.json'
			});

			// Assert
			expect(mockConsoleLog).toHaveBeenCalledWith(
				expect.stringContaining('No PRD file specified')
			);
			expect(mockParsePRD).not.toHaveBeenCalled();
		});

		test('should use explicitly provided file path', async () => {
			// Arrange
			const testFile = 'test/prd.txt';

			// Act - call the handler directly with the right params
			await parsePrdAction(testFile, {
				numTasks: '10',
				output: 'tasks/tasks.json'
			});

			// Assert
			expect(mockConsoleLog).toHaveBeenCalledWith(
				expect.stringContaining(`Parsing PRD file: ${testFile}`)
			);
			expect(mockParsePRD).toHaveBeenCalledWith(
				testFile,
				'tasks/tasks.json',
				10
			);
			expect(mockExistsSync).not.toHaveBeenCalledWith('scripts/prd.txt');
		});

		test('should use file path from input option when provided', async () => {
			// Arrange
			const testFile = 'test/prd.txt';

			// Act - call the handler directly with the right params
			await parsePrdAction(undefined, {
				input: testFile,
				numTasks: '10',
				output: 'tasks/tasks.json'
			});

			// Assert
			expect(mockConsoleLog).toHaveBeenCalledWith(
				expect.stringContaining(`Parsing PRD file: ${testFile}`)
			);
			expect(mockParsePRD).toHaveBeenCalledWith(
				testFile,
				'tasks/tasks.json',
				10
			);
			expect(mockExistsSync).not.toHaveBeenCalledWith('scripts/prd.txt');
		});

		test('should respect numTasks and output options', async () => {
			// Arrange
			const testFile = 'test/prd.txt';
			const outputFile = 'custom/output.json';
			const numTasks = 15;

			// Act - call the handler directly with the right params
			await parsePrdAction(testFile, {
				numTasks: numTasks.toString(),
				output: outputFile
			});

			// Assert
			expect(mockParsePRD).toHaveBeenCalledWith(testFile, outputFile, numTasks);
		});
	});

	describe('updateTask command', () => {
		// Since mocking Commander is complex, we'll test the action handler directly
		// Recreate the action handler logic based on commands.js
		async function updateTaskAction(options) {
			try {
				const tasksPath = options.file;

				// Validate required parameters
				if (!options.id) {
					console.error(chalk.red('Error: --id parameter is required'));
					console.log(
						chalk.yellow(
							'Usage example: task-master update-task --id=23 --prompt="Update with new information"'
						)
					);
					process.exit(1);
					return; // Add early return to prevent calling updateTaskById
				}

				// Parse the task ID and validate it's a number
				const taskId = parseInt(options.id, 10);
				if (isNaN(taskId) || taskId <= 0) {
					console.error(
						chalk.red(
							`Error: Invalid task ID: ${options.id}. Task ID must be a positive integer.`
						)
					);
					console.log(
						chalk.yellow(
							'Usage example: task-master update-task --id=23 --prompt="Update with new information"'
						)
					);
					process.exit(1);
					return; // Add early return to prevent calling updateTaskById
				}

				if (!options.prompt) {
					console.error(
						chalk.red(
							'Error: --prompt parameter is required. Please provide information about the changes.'
						)
					);
					console.log(
						chalk.yellow(
							'Usage example: task-master update-task --id=23 --prompt="Update with new information"'
						)
					);
					process.exit(1);
					return; // Add early return to prevent calling updateTaskById
				}

				const prompt = options.prompt;
				const useResearch = options.research || false;

				// Validate tasks file exists
				if (!fs.existsSync(tasksPath)) {
					console.error(
						chalk.red(`Error: Tasks file not found at path: ${tasksPath}`)
					);
					if (tasksPath === 'tasks/tasks.json') {
						console.log(
							chalk.yellow(
								'Hint: Run task-master init or task-master parse-prd to create tasks.json first'
							)
						);
					} else {
						console.log(
							chalk.yellow(
								`Hint: Check if the file path is correct: ${tasksPath}`
							)
						);
					}
					process.exit(1);
					return; // Add early return to prevent calling updateTaskById
				}

				console.log(
					chalk.blue(`Updating task ${taskId} with prompt: "${prompt}"`)
				);
				console.log(chalk.blue(`Tasks file: ${tasksPath}`));

				if (useResearch) {
					// Verify Perplexity API key exists if using research
					if (!process.env.PERPLEXITY_API_KEY) {
						console.log(
							chalk.yellow(
								'Warning: PERPLEXITY_API_KEY environment variable is missing. Research-backed updates will not be available.'
							)
						);
						console.log(
							chalk.yellow('Falling back to Claude AI for task update.')
						);
					} else {
						console.log(
							chalk.blue('Using Perplexity AI for research-backed task update')
						);
					}
				}

				const result = await mockUpdateTaskById(
					tasksPath,
					taskId,
					prompt,
					useResearch
				);

				// If the task wasn't updated (e.g., if it was already marked as done)
				if (!result) {
					console.log(
						chalk.yellow(
							'\nTask update was not completed. Review the messages above for details.'
						)
					);
				}
			} catch (error) {
				console.error(chalk.red(`Error: ${error.message}`));

				// Provide more helpful error messages for common issues
				if (
					error.message.includes('task') &&
					error.message.includes('not found')
				) {
					console.log(chalk.yellow('\nTo fix this issue:'));
					console.log(
						'  1. Run task-master list to see all available task IDs'
					);
					console.log('  2. Use a valid task ID with the --id parameter');
				} else if (error.message.includes('API key')) {
					console.log(
						chalk.yellow(
							'\nThis error is related to API keys. Check your environment variables.'
						)
					);
				}

				if (true) {
					// CONFIG.debug
					console.error(error);
				}

				process.exit(1);
			}
		}

		beforeEach(() => {
			// Reset all mocks
			jest.clearAllMocks();

			// Set up spy for existsSync (already mocked in the outer scope)
			mockExistsSync.mockReturnValue(true);
		});

		test('should validate required parameters - missing ID', async () => {
			// Set up the command options without ID
			const options = {
				file: 'test-tasks.json',
				prompt: 'Update the task'
			};

			// Call the action directly
			await updateTaskAction(options);

			// Verify validation error
			expect(mockConsoleError).toHaveBeenCalledWith(
				expect.stringContaining('--id parameter is required')
			);
			expect(mockExit).toHaveBeenCalledWith(1);
			expect(mockUpdateTaskById).not.toHaveBeenCalled();
		});

		test('should validate required parameters - invalid ID', async () => {
			// Set up the command options with invalid ID
			const options = {
				file: 'test-tasks.json',
				id: 'not-a-number',
				prompt: 'Update the task'
			};

			// Call the action directly
			await updateTaskAction(options);

			// Verify validation error
			expect(mockConsoleError).toHaveBeenCalledWith(
				expect.stringContaining('Invalid task ID')
			);
			expect(mockExit).toHaveBeenCalledWith(1);
			expect(mockUpdateTaskById).not.toHaveBeenCalled();
		});

		test('should validate required parameters - missing prompt', async () => {
			// Set up the command options without prompt
			const options = {
				file: 'test-tasks.json',
				id: '2'
			};

			// Call the action directly
			await updateTaskAction(options);

			// Verify validation error
			expect(mockConsoleError).toHaveBeenCalledWith(
				expect.stringContaining('--prompt parameter is required')
			);
			expect(mockExit).toHaveBeenCalledWith(1);
			expect(mockUpdateTaskById).not.toHaveBeenCalled();
		});

		test('should validate tasks file exists', async () => {
			// Mock file not existing
			mockExistsSync.mockReturnValue(false);

			// Set up the command options
			const options = {
				file: 'missing-tasks.json',
				id: '2',
				prompt: 'Update the task'
			};

			// Call the action directly
			await updateTaskAction(options);

			// Verify validation error
			expect(mockConsoleError).toHaveBeenCalledWith(
				expect.stringContaining('Tasks file not found')
			);
			expect(mockExit).toHaveBeenCalledWith(1);
			expect(mockUpdateTaskById).not.toHaveBeenCalled();
		});

		test('should call updateTaskById with correct parameters', async () => {
			// Set up the command options
			const options = {
				file: 'test-tasks.json',
				id: '2',
				prompt: 'Update the task',
				research: true
			};

			// Mock perplexity API key
			process.env.PERPLEXITY_API_KEY = 'dummy-key';

			// Call the action directly
			await updateTaskAction(options);

			// Verify updateTaskById was called with correct parameters
			expect(mockUpdateTaskById).toHaveBeenCalledWith(
				'test-tasks.json',
				2,
				'Update the task',
				true
			);

			// Verify console output
			expect(mockConsoleLog).toHaveBeenCalledWith(
				expect.stringContaining('Updating task 2')
			);
			expect(mockConsoleLog).toHaveBeenCalledWith(
				expect.stringContaining('Using Perplexity AI')
			);

			// Clean up
			delete process.env.PERPLEXITY_API_KEY;
		});

		test('should handle null result from updateTaskById', async () => {
			// Mock updateTaskById returning null (e.g., task already completed)
			mockUpdateTaskById.mockResolvedValueOnce(null);

			// Set up the command options
			const options = {
				file: 'test-tasks.json',
				id: '2',
				prompt: 'Update the task'
			};

			// Call the action directly
			await updateTaskAction(options);

			// Verify updateTaskById was called
			expect(mockUpdateTaskById).toHaveBeenCalled();

			// Verify console output for null result
			expect(mockConsoleLog).toHaveBeenCalledWith(
				expect.stringContaining('Task update was not completed')
			);
		});

		test('should handle errors from updateTaskById', async () => {
			// Mock updateTaskById throwing an error
			mockUpdateTaskById.mockRejectedValueOnce(new Error('Task update failed'));

			// Set up the command options
			const options = {
				file: 'test-tasks.json',
				id: '2',
				prompt: 'Update the task'
			};

			// Call the action directly
			await updateTaskAction(options);

			// Verify error handling
			expect(mockConsoleError).toHaveBeenCalledWith(
				expect.stringContaining('Error: Task update failed')
			);
			expect(mockExit).toHaveBeenCalledWith(1);
		});
	});
});

// Test the version comparison utility
describe('Version comparison', () => {
	// Use a dynamic import for the commands module
	let compareVersions;

	beforeAll(async () => {
		// Import the function we want to test dynamically
		const commandsModule = await import('../../scripts/modules/commands.js');
		compareVersions = commandsModule.compareVersions;
	});

	test('compareVersions correctly compares semantic versions', () => {
		expect(compareVersions('1.0.0', '1.0.0')).toBe(0);
		expect(compareVersions('1.0.0', '1.0.1')).toBe(-1);
		expect(compareVersions('1.0.1', '1.0.0')).toBe(1);
		expect(compareVersions('1.0.0', '1.1.0')).toBe(-1);
		expect(compareVersions('1.1.0', '1.0.0')).toBe(1);
		expect(compareVersions('1.0.0', '2.0.0')).toBe(-1);
		expect(compareVersions('2.0.0', '1.0.0')).toBe(1);
		expect(compareVersions('1.0', '1.0.0')).toBe(0);
		expect(compareVersions('1.0.0.0', '1.0.0')).toBe(0);
		expect(compareVersions('1.0.0', '1.0.0.1')).toBe(-1);
	});
});

// Test the update check functionality
describe('Update check', () => {
	let displayUpgradeNotification;
	let consoleLogSpy;

	beforeAll(async () => {
		// Import the function we want to test dynamically
		const commandsModule = await import('../../scripts/modules/commands.js');
		displayUpgradeNotification = commandsModule.displayUpgradeNotification;
	});

	beforeEach(() => {
		// Spy on console.log
		consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
	});

	afterEach(() => {
		consoleLogSpy.mockRestore();
	});

	test('displays upgrade notification when newer version is available', () => {
		// Test displayUpgradeNotification function
		displayUpgradeNotification('1.0.0', '1.1.0');
		expect(consoleLogSpy).toHaveBeenCalled();
		expect(consoleLogSpy.mock.calls[0][0]).toContain('Update Available!');
		expect(consoleLogSpy.mock.calls[0][0]).toContain('1.0.0');
		expect(consoleLogSpy.mock.calls[0][0]).toContain('1.1.0');
	});
});