claude-task-master/tests/unit/mcp/tools/add-task.test.js

/**
 * Tests for the add-task MCP tool
 *
 * Note: This test does NOT test the actual implementation. It tests that:
 * 1. The tool is registered correctly with the correct parameters
 * 2. Arguments are passed correctly to addTaskDirect
 * 3. Error handling works as expected
 *
 * We do NOT import the real implementation - everything is mocked
 */

import { jest } from '@jest/globals';
import {
	sampleTasks,
	emptySampleTasks
} from '../../../fixtures/sample-tasks.js';

// Mock EVERYTHING
const mockAddTaskDirect = jest.fn();
jest.mock('../../../../mcp-server/src/core/task-master-core.js', () => ({
	addTaskDirect: mockAddTaskDirect
}));

const mockHandleApiResult = jest.fn((result) => result);
const mockGetProjectRootFromSession = jest.fn(() => '/mock/project/root');
const mockCreateErrorResponse = jest.fn((msg) => ({
	success: false,
	error: { code: 'ERROR', message: msg }
}));

jest.mock('../../../../mcp-server/src/tools/utils.js', () => ({
	getProjectRootFromSession: mockGetProjectRootFromSession,
	handleApiResult: mockHandleApiResult,
	createErrorResponse: mockCreateErrorResponse,
	createContentResponse: jest.fn((content) => ({
		success: true,
		data: content
	})),
	executeTaskMasterCommand: jest.fn()
}));

// Mock the z object from zod
const mockZod = {
	object: jest.fn(() => mockZod),
	string: jest.fn(() => mockZod),
	boolean: jest.fn(() => mockZod),
	optional: jest.fn(() => mockZod),
	describe: jest.fn(() => mockZod),
	_def: {
		shape: () => ({
			prompt: {},
			dependencies: {},
			priority: {},
			research: {},
			file: {},
			projectRoot: {}
		})
	}
};

jest.mock('zod', () => ({
	z: mockZod
}));

// DO NOT import the real module - create a fake implementation
// This is the fake implementation of registerAddTaskTool
const registerAddTaskTool = (server) => {
	// Create simplified version of the tool config
	const toolConfig = {
		name: 'add_task',
		description: 'Add a new task using AI',
		parameters: mockZod,

		// Create a simplified mock of the execute function
		execute: (args, context) => {
			const { log, reportProgress, session } = context;

			try {
				log.info &&
					log.info(`Starting add-task with args: ${JSON.stringify(args)}`);

				// Get project root
				const rootFolder = mockGetProjectRootFromSession(session, log);

				// Call addTaskDirect
				const result = mockAddTaskDirect(
					{
						...args,
						projectRoot: rootFolder
					},
					log,
					{ reportProgress, session }
				);

				// Handle result
				return mockHandleApiResult(result, log);
			} catch (error) {
				log.error && log.error(`Error in add-task tool: ${error.message}`);
				return mockCreateErrorResponse(error.message);
			}
		}
	};

	// Register the tool with the server
	server.addTool(toolConfig);
};

describe('MCP Tool: add-task', () => {
	// Create mock server
	let mockServer;
	let executeFunction;

	// Create mock logger
	const mockLogger = {
		debug: jest.fn(),
		info: jest.fn(),
		warn: jest.fn(),
		error: jest.fn()
	};

	// Test data
	const validArgs = {
		prompt: 'Create a new task',
		dependencies: '1,2',
		priority: 'high',
		research: true
	};

	// Standard responses
	const successResponse = {
		success: true,
		data: {
			taskId: '5',
			message: 'Successfully added new task #5'
		}
	};

	const errorResponse = {
		success: false,
		error: {
			code: 'ADD_TASK_ERROR',
			message: 'Failed to add task'
		}
	};

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

		// Create mock server
		mockServer = {
			addTool: jest.fn((config) => {
				executeFunction = config.execute;
			})
		};

		// Setup default successful response
		mockAddTaskDirect.mockReturnValue(successResponse);

		// Register the tool
		registerAddTaskTool(mockServer);
	});

	test('should register the tool correctly', () => {
		// Verify tool was registered
		expect(mockServer.addTool).toHaveBeenCalledWith(
			expect.objectContaining({
				name: 'add_task',
				description: 'Add a new task using AI',
				parameters: expect.any(Object),
				execute: expect.any(Function)
			})
		);

		// Verify the tool config was passed
		const toolConfig = mockServer.addTool.mock.calls[0][0];
		expect(toolConfig).toHaveProperty('parameters');
		expect(toolConfig).toHaveProperty('execute');
	});

	test('should execute the tool with valid parameters', () => {
		// Setup context
		const mockContext = {
			log: mockLogger,
			reportProgress: jest.fn(),
			session: { workingDirectory: '/mock/dir' }
		};

		// Execute the function
		executeFunction(validArgs, mockContext);

		// Verify getProjectRootFromSession was called
		expect(mockGetProjectRootFromSession).toHaveBeenCalledWith(
			mockContext.session,
			mockLogger
		);

		// Verify addTaskDirect was called with correct arguments
		expect(mockAddTaskDirect).toHaveBeenCalledWith(
			expect.objectContaining({
				...validArgs,
				projectRoot: '/mock/project/root'
			}),
			mockLogger,
			{
				reportProgress: mockContext.reportProgress,
				session: mockContext.session
			}
		);

		// Verify handleApiResult was called
		expect(mockHandleApiResult).toHaveBeenCalledWith(
			successResponse,
			mockLogger
		);
	});

	test('should handle errors from addTaskDirect', () => {
		// Setup error response
		mockAddTaskDirect.mockReturnValueOnce(errorResponse);

		// Setup context
		const mockContext = {
			log: mockLogger,
			reportProgress: jest.fn(),
			session: { workingDirectory: '/mock/dir' }
		};

		// Execute the function
		executeFunction(validArgs, mockContext);

		// Verify addTaskDirect was called
		expect(mockAddTaskDirect).toHaveBeenCalled();

		// Verify handleApiResult was called with error response
		expect(mockHandleApiResult).toHaveBeenCalledWith(errorResponse, mockLogger);
	});

	test('should handle unexpected errors', () => {
		// Setup error
		const testError = new Error('Unexpected error');
		mockAddTaskDirect.mockImplementationOnce(() => {
			throw testError;
		});

		// Setup context
		const mockContext = {
			log: mockLogger,
			reportProgress: jest.fn(),
			session: { workingDirectory: '/mock/dir' }
		};

		// Execute the function
		executeFunction(validArgs, mockContext);

		// Verify error was logged
		expect(mockLogger.error).toHaveBeenCalledWith(
			'Error in add-task tool: Unexpected error'
		);

		// Verify error response was created
		expect(mockCreateErrorResponse).toHaveBeenCalledWith('Unexpected error');
	});

	test('should pass research parameter correctly', () => {
		// Setup context
		const mockContext = {
			log: mockLogger,
			reportProgress: jest.fn(),
			session: { workingDirectory: '/mock/dir' }
		};

		// Test with research=true
		executeFunction(
			{
				...validArgs,
				research: true
			},
			mockContext
		);

		// Verify addTaskDirect was called with research=true
		expect(mockAddTaskDirect).toHaveBeenCalledWith(
			expect.objectContaining({
				research: true
			}),
			expect.any(Object),
			expect.any(Object)
		);

		// Reset mocks
		jest.clearAllMocks();

		// Test with research=false
		executeFunction(
			{
				...validArgs,
				research: false
			},
			mockContext
		);

		// Verify addTaskDirect was called with research=false
		expect(mockAddTaskDirect).toHaveBeenCalledWith(
			expect.objectContaining({
				research: false
			}),
			expect.any(Object),
			expect.any(Object)
		);
	});

	test('should pass priority parameter correctly', () => {
		// Setup context
		const mockContext = {
			log: mockLogger,
			reportProgress: jest.fn(),
			session: { workingDirectory: '/mock/dir' }
		};

		// Test different priority values
		['high', 'medium', 'low'].forEach((priority) => {
			// Reset mocks
			jest.clearAllMocks();

			// Execute with specific priority
			executeFunction(
				{
					...validArgs,
					priority
				},
				mockContext
			);

			// Verify addTaskDirect was called with correct priority
			expect(mockAddTaskDirect).toHaveBeenCalledWith(
				expect.objectContaining({
					priority
				}),
				expect.any(Object),
				expect.any(Object)
			);
		});
	});
});