claude-task-master/tests/integration/mcp-server/direct-functions.test.js

/**
 * Integration test for direct function imports in MCP server
 */

import { jest } from '@jest/globals';
import path from 'path';
import fs from 'fs';
import { fileURLToPath } from 'url';
import { dirname } from 'path';

// Get the current module's directory
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

// Import the direct functions
import { listTasksDirect } from '../../../mcp-server/src/core/task-master-core.js';

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

// Test file paths
const testProjectRoot = path.join(__dirname, '../../fixture');
const testTasksPath = path.join(testProjectRoot, 'test-tasks.json');

describe('MCP Server Direct Functions', () => {
	// Create test data before tests
	beforeAll(() => {
		// Create test directory if it doesn't exist
		if (!fs.existsSync(testProjectRoot)) {
			fs.mkdirSync(testProjectRoot, { recursive: true });
		}

		// Create a sample tasks.json file for testing
		const sampleTasks = {
			meta: {
				projectName: 'Test Project',
				version: '1.0.0'
			},
			tasks: [
				{
					id: 1,
					title: 'Task 1',
					description: 'First task',
					status: 'done',
					dependencies: [],
					priority: 'high'
				},
				{
					id: 2,
					title: 'Task 2',
					description: 'Second task',
					status: 'in-progress',
					dependencies: [1],
					priority: 'medium',
					subtasks: [
						{
							id: 1,
							title: 'Subtask 2.1',
							description: 'First subtask',
							status: 'done'
						},
						{
							id: 2,
							title: 'Subtask 2.2',
							description: 'Second subtask',
							status: 'pending'
						}
					]
				},
				{
					id: 3,
					title: 'Task 3',
					description: 'Third task',
					status: 'pending',
					dependencies: [1, 2],
					priority: 'low'
				}
			]
		};

		fs.writeFileSync(testTasksPath, JSON.stringify(sampleTasks, null, 2));
	});

	// Clean up after tests
	afterAll(() => {
		// Remove test tasks file
		if (fs.existsSync(testTasksPath)) {
			fs.unlinkSync(testTasksPath);
		}

		// Try to remove the directory (will only work if empty)
		try {
			fs.rmdirSync(testProjectRoot);
		} catch (error) {
			// Ignore errors if the directory isn't empty
		}
	});

	// Reset mocks before each test
	beforeEach(() => {
		jest.clearAllMocks();
	});

	describe('listTasksDirect', () => {
		test('should return all tasks when no filter is provided', async () => {
			// Arrange
			const args = {
				projectRoot: testProjectRoot,
				file: testTasksPath
			};

			// Act
			const result = await listTasksDirect(args, mockLogger);

			// Assert
			expect(result.success).toBe(true);
			expect(result.data.tasks.length).toBe(3);
			expect(result.data.stats.total).toBe(3);
			expect(result.data.stats.completed).toBe(1);
			expect(result.data.stats.inProgress).toBe(1);
			expect(result.data.stats.pending).toBe(1);
			expect(mockLogger.info).toHaveBeenCalled();
		});

		test('should filter tasks by status', async () => {
			// Arrange
			const args = {
				projectRoot: testProjectRoot,
				file: testTasksPath,
				status: 'pending'
			};

			// Act
			const result = await listTasksDirect(args, mockLogger);

			// Assert
			expect(result.success).toBe(true);
			expect(result.data.tasks.length).toBe(1);
			expect(result.data.tasks[0].id).toBe(3);
			expect(result.data.filter).toBe('pending');
		});

		test('should include subtasks when requested', async () => {
			// Arrange
			const args = {
				projectRoot: testProjectRoot,
				file: testTasksPath,
				withSubtasks: true
			};

			// Act
			const result = await listTasksDirect(args, mockLogger);

			// Assert
			expect(result.success).toBe(true);

			// Verify subtasks are included
			const taskWithSubtasks = result.data.tasks.find((t) => t.id === 2);
			expect(taskWithSubtasks.subtasks).toBeDefined();
			expect(taskWithSubtasks.subtasks.length).toBe(2);

			// Verify subtask details
			expect(taskWithSubtasks.subtasks[0].id).toBe(1);
			expect(taskWithSubtasks.subtasks[0].title).toBe('Subtask 2.1');
			expect(taskWithSubtasks.subtasks[0].status).toBe('done');
		});

		test('should handle errors gracefully', async () => {
			// Arrange
			const args = {
				projectRoot: testProjectRoot,
				file: 'non-existent-file.json'
			};

			// Act
			const result = await listTasksDirect(args, mockLogger);

			// Assert
			expect(result.success).toBe(false);
			expect(result.error).toBeDefined();
			expect(result.error.code).toBeDefined();
			expect(result.error.message).toBeDefined();
			expect(mockLogger.error).toHaveBeenCalled();
		});
	});
});