claude-task-master/tests/integration/commands/update-tasks.test.js

import updateTasks from '../../../scripts/modules/task-manager/update-tasks.js';
import { readJSON, writeJSON } from '../../../scripts/modules/utils.js';
import fs from 'fs';
import path from 'path';

describe('update-tasks with generateObject', () => {
	const testTasksFile = path.join(process.cwd(), 'test-tasks.json');

	beforeEach(() => {
		// Create a test tasks file
		const testTasks = {
			projectName: 'Test Project',
			tasks: [
				{
					id: 1,
					title: 'Setup project structure',
					description: 'Initialize the project with proper folder structure',
					status: 'done',
					dependencies: [],
					priority: 'high',
					details: 'Create folders for src, tests, docs',
					testStrategy: 'Manual verification',
					subtasks: []
				},
				{
					id: 2,
					title: 'Implement authentication',
					description: 'Add user authentication with JWT tokens',
					status: 'pending',
					dependencies: [1],
					priority: 'high',
					details: 'Need to support OAuth2 and traditional login',
					testStrategy: null,
					subtasks: [
						{
							id: 1,
							title: 'Design auth flow',
							description: 'Create authentication flow diagrams',
							status: 'done',
							dependencies: []
						}
					]
				},
				{
					id: 3,
					title: 'Build API endpoints',
					description: 'Create RESTful API endpoints',
					status: 'in-progress',
					dependencies: [2],
					priority: 'medium',
					details: 'Use Express.js for the API',
					testStrategy: 'Integration tests with Jest',
					subtasks: []
				},
				{
					id: 4,
					title: 'Add database layer',
					description: 'Implement database models and migrations',
					status: 'pending',
					dependencies: [1],
					priority: 'high',
					details: null,
					testStrategy: null,
					subtasks: []
				}
			]
		};
		fs.writeFileSync(testTasksFile, JSON.stringify(testTasks, null, 2));
	});

	afterEach(() => {
		// Clean up test files
		if (fs.existsSync(testTasksFile)) {
			fs.unlinkSync(testTasksFile);
		}
	});

	test('should update multiple tasks with structured data', async () => {
		const result = await updateTasks(
			testTasksFile,
			2, // Update from task ID 2 onwards
			'Switch to microservices architecture with Docker containers'
		);

		expect(result).toBeDefined();
		expect(result).toHaveProperty('updatedTasks');
		expect(result).toHaveProperty('telemetryData');

		// Read the updated file
		const updatedData = JSON.parse(fs.readFileSync(testTasksFile, 'utf8'));

		// Task 1 should remain unchanged (status: done)
		const task1 = updatedData.tasks.find((t) => t.id === 1);
		expect(task1.title).toBe('Setup project structure');
		expect(task1.status).toBe('done');

		// Tasks 2, 3, and 4 should be updated
		const task2 = updatedData.tasks.find((t) => t.id === 2);
		expect(task2.description.toLowerCase()).toContain('microservice');
		// Completed subtasks should be preserved
		expect(
			task2.subtasks.find((st) => st.id === 1 && st.status === 'done')
		).toBeDefined();

		const task3 = updatedData.tasks.find((t) => t.id === 3);
		expect(task3.description.toLowerCase()).toContain('docker');

		const task4 = updatedData.tasks.find((t) => t.id === 4);
		expect(task4.description.toLowerCase()).toMatch(
			/microservice|docker|container/
		);
	}, 30000); // Increase timeout for AI call

	test('should preserve completed subtasks when updating', async () => {
		await updateTasks(
			testTasksFile,
			2,
			'Add comprehensive error handling and logging'
		);

		const updatedData = JSON.parse(fs.readFileSync(testTasksFile, 'utf8'));
		const task2 = updatedData.tasks.find((t) => t.id === 2);

		// Find the completed subtask
		const completedSubtask = task2.subtasks.find((st) => st.id === 1);
		expect(completedSubtask).toBeDefined();
		expect(completedSubtask.status).toBe('done');
		expect(completedSubtask.title).toBe('Design auth flow');
		expect(completedSubtask.description).toBe(
			'Create authentication flow diagrams'
		);
	}, 30000);

	test('should handle no tasks to update', async () => {
		const result = await updateTasks(
			testTasksFile,
			10, // Start from non-existent task ID
			'Update all tasks'
		);

		expect(result).toBeUndefined();

		// File should remain unchanged
		const data = JSON.parse(fs.readFileSync(testTasksFile, 'utf8'));
		expect(data.tasks.length).toBe(4);
	}, 30000);
});