ros/claude-task-master
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: resolve all remaining test failures and improve test reliability

Browse Source 
- Fix clear-subtasks test by implementing deep copy of mock data to prevent mutation issues between tests
- Fix add-task test by uncommenting and properly configuring generateTaskFiles call with correct parameters
- Fix analyze-task-complexity tests by properly mocking fs.writeFileSync with shared mock function
- Update test expectations to match actual function signatures and data structures
- Improve mock setup consistency across all test suites
- Ensure all tests now pass (329 total: 318 passed, 11 skipped, 0 failed)
This commit is contained in:
Eyal Toledano
2025-06-13 22:31:24 -04:00
parent 2e2d290c63
commit d5360f625f
22 changed files with 1119 additions and 7640 deletions
Download Patch File Download Diff File Expand all files Collapse all files

204
tests/unit/scripts/modules/task-manager/parse-prd.test.js
View File

@@ -20,6 +20,8 @@ jest.unstable_mockModule('../../../../../scripts/modules/utils.js', () => ({
enableSilentMode: jest.fn(),
disableSilentMode: jest.fn(),
findTaskById: jest.fn(),
ensureTagMetadata: jest.fn((tagObj) => tagObj),
getCurrentTag: jest.fn(() => 'master'),
promptYesNo: jest.fn()
}));
@@ -122,8 +124,7 @@ const sampleClaudeResponse = {
description: 'Initialize the project with necessary files and folders',
status: 'pending',
dependencies: [],
priority: 'high',
subtasks: []
priority: 'high'
},
{
id: 2,
@@ -131,30 +132,43 @@ const sampleClaudeResponse = {
description: 'Build the main functionality',
status: 'pending',
dependencies: [1],
priority: 'high',
subtasks: []
priority: 'high'
}
]
],
metadata: {
projectName: 'Test Project',
totalTasks: 2,
sourceFile: 'path/to/prd.txt',
generatedAt: expect.any(String)
}
};
describe('parsePRD', () => {
// Mock the sample PRD content
const samplePRDContent = '# Sample PRD for Testing';
// Mock existing tasks for append test
const existingTasks = {
tasks: [
{ id: 1, title: 'Existing Task 1', status: 'done' },
{ id: 2, title: 'Existing Task 2', status: 'pending' }
]
// Mock existing tasks for append test - TAGGED FORMAT
const existingTasksData = {
master: {
tasks: [
{ id: 1, title: 'Existing Task 1', status: 'done' },
{ id: 2, title: 'Existing Task 2', status: 'pending' }
]
}
};
// Mock new tasks with continuing IDs for append test
const newTasksWithContinuedIds = {
const newTasksClaudeResponse = {
tasks: [
{ id: 3, title: 'New Task 3' },
{ id: 4, title: 'New Task 4' }
]
],
metadata: {
projectName: 'Test Project',
totalTasks: 2,
sourceFile: 'path/to/prd.txt',
generatedAt: expect.any(String)
}
};
beforeEach(() => {
@@ -166,7 +180,7 @@ describe('parsePRD', () => {
fs.default.existsSync.mockReturnValue(true);
path.default.dirname.mockReturnValue('tasks');
generateObjectService.mockResolvedValue({
mainResult: sampleClaudeResponse,
mainResult: { object: sampleClaudeResponse },
telemetryData: {}
});
generateTaskFiles.mockResolvedValue(undefined);
@@ -184,9 +198,9 @@ describe('parsePRD', () => {
test('should parse a PRD file and generate tasks', async () => {
// Setup mocks to simulate normal conditions (no existing output file)
fs.default.existsSync.mockImplementation((path) => {
if (path === 'tasks/tasks.json') return false; // Output file doesn't exist
if (path === 'tasks') return true; // Directory exists
fs.default.existsSync.mockImplementation((p) => {
if (p === 'tasks/tasks.json') return false; // Output file doesn't exist
if (p === 'tasks') return true; // Directory exists
return false;
});
@@ -205,19 +219,12 @@ describe('parsePRD', () => {
// Verify directory check
expect(fs.default.existsSync).toHaveBeenCalledWith('tasks');
// Verify writeJSON was called with the correct arguments
expect(writeJSON).toHaveBeenCalledWith(
// Verify fs.writeFileSync was called with the correct arguments in tagged format
expect(fs.default.writeFileSync).toHaveBeenCalledWith(
'tasks/tasks.json',
sampleClaudeResponse
expect.stringContaining('"master"')
);
// // Verify generateTaskFiles was called
// expect(generateTaskFiles).toHaveBeenCalledWith(
// 'tasks/tasks.json',
// 'tasks',
// { mcpLog: undefined }
// );
// Verify result
expect(result).toEqual({
success: true,
@@ -225,17 +232,18 @@ describe('parsePRD', () => {
telemetryData: {}
});
// Verify that the written data contains 2 tasks from sampleClaudeResponse
const writtenData = writeJSON.mock.calls[0][1];
expect(writtenData.tasks.length).toBe(2);
// Verify that the written data contains 2 tasks from sampleClaudeResponse in the correct tag
const writtenDataString = fs.default.writeFileSync.mock.calls[0][1];
const writtenData = JSON.parse(writtenDataString);
expect(writtenData.master.tasks.length).toBe(2);
});
test('should create the tasks directory if it does not exist', async () => {
// Mock existsSync to return false specifically for the directory check
// but true for the output file check (so we don't trigger confirmation path)
fs.default.existsSync.mockImplementation((path) => {
if (path === 'tasks/tasks.json') return false; // Output file doesn't exist
if (path === 'tasks') return false; // Directory doesn't exist
fs.default.existsSync.mockImplementation((p) => {
if (p === 'tasks/tasks.json') return false; // Output file doesn't exist
if (p === 'tasks') return false; // Directory doesn't exist
return true; // Default for other paths
});
@@ -254,9 +262,9 @@ describe('parsePRD', () => {
generateObjectService.mockRejectedValueOnce(testError);
// Setup mocks to simulate normal file conditions (no existing file)
fs.default.existsSync.mockImplementation((path) => {
if (path === 'tasks/tasks.json') return false; // Output file doesn't exist
if (path === 'tasks') return true; // Directory exists
fs.default.existsSync.mockImplementation((p) => {
if (p === 'tasks/tasks.json') return false; // Output file doesn't exist
if (p === 'tasks') return true; // Directory exists
return false;
});
@@ -276,28 +284,21 @@ describe('parsePRD', () => {
test('should generate individual task files after creating tasks.json', async () => {
// Setup mocks to simulate normal conditions (no existing output file)
fs.default.existsSync.mockImplementation((path) => {
if (path === 'tasks/tasks.json') return false; // Output file doesn't exist
if (path === 'tasks') return true; // Directory exists
fs.default.existsSync.mockImplementation((p) => {
if (p === 'tasks/tasks.json') return false; // Output file doesn't exist
if (p === 'tasks') return true; // Directory exists
return false;
});
// Call the function
await parsePRD('path/to/prd.txt', 'tasks/tasks.json', 3);
// // Verify generateTaskFiles was called
// expect(generateTaskFiles).toHaveBeenCalledWith(
// 'tasks/tasks.json',
// 'tasks',
// { mcpLog: undefined }
// );
});
test('should overwrite tasks.json when force flag is true', async () => {
// Setup mocks to simulate tasks.json already exists
fs.default.existsSync.mockImplementation((path) => {
if (path === 'tasks/tasks.json') return true; // Output file exists
if (path === 'tasks') return true; // Directory exists
fs.default.existsSync.mockImplementation((p) => {
if (p === 'tasks/tasks.json') return true; // Output file exists
if (p === 'tasks') return true; // Directory exists
return false;
});
@@ -308,19 +309,19 @@ describe('parsePRD', () => {
expect(promptYesNo).not.toHaveBeenCalled();
// Verify the file was written after force overwrite
expect(writeJSON).toHaveBeenCalledWith(
expect(fs.default.writeFileSync).toHaveBeenCalledWith(
'tasks/tasks.json',
sampleClaudeResponse
expect.stringContaining('"master"')
);
});
test('should throw error when tasks.json exists without force flag in MCP mode', async () => {
// Setup mocks to simulate tasks.json already exists
fs.default.existsSync.mockImplementation((path) => {
if (path === 'tasks/tasks.json') return true; // Output file exists
if (path === 'tasks') return true; // Directory exists
return false;
});
test('should throw error when tasks in tag exist without force flag in MCP mode', async () => {
// Setup mocks to simulate tasks.json already exists with tasks in the target tag
fs.default.existsSync.mockReturnValue(true);
// Mock readFileSync to return data with tasks in the 'master' tag
fs.default.readFileSync.mockReturnValueOnce(
JSON.stringify(existingTasksData)
);
// Call the function with mcpLog to make it think it's in MCP mode (which throws instead of process.exit)
await expect(
@@ -333,22 +334,23 @@ describe('parsePRD', () => {
success: jest.fn()
}
})
).rejects.toThrow('Output file tasks/tasks.json already exists');
).rejects.toThrow(
"Tag 'master' already contains 2 tasks. Use --force to overwrite or --append to add to existing tasks."
);
// Verify prompt was NOT called (confirmation happens at CLI level, not in core function)
// Verify prompt was NOT called
expect(promptYesNo).not.toHaveBeenCalled();
// Verify the file was NOT written
expect(writeJSON).not.toHaveBeenCalled();
expect(fs.default.writeFileSync).not.toHaveBeenCalled();
});
test('should call process.exit when tasks.json exists without force flag in CLI mode', async () => {
// Setup mocks to simulate tasks.json already exists
fs.default.existsSync.mockImplementation((path) => {
if (path === 'tasks/tasks.json') return true; // Output file exists
if (path === 'tasks') return true; // Directory exists
return false;
});
test('should call process.exit when tasks in tag exist without force flag in CLI mode', async () => {
// Setup mocks to simulate tasks.json already exists with tasks in the target tag
fs.default.existsSync.mockReturnValue(true);
fs.default.readFileSync.mockReturnValueOnce(
JSON.stringify(existingTasksData)
);
// Mock process.exit for this specific test
const mockProcessExit = jest
@@ -366,47 +368,26 @@ describe('parsePRD', () => {
expect(mockProcessExit).toHaveBeenCalledWith(1);
// Verify the file was NOT written
expect(writeJSON).not.toHaveBeenCalled();
expect(fs.default.writeFileSync).not.toHaveBeenCalled();
// Restore the mock
mockProcessExit.mockRestore();
});
test('should not prompt for confirmation when tasks.json does not exist', async () => {
// Setup mocks to simulate tasks.json does not exist
fs.default.existsSync.mockImplementation((path) => {
if (path === 'tasks/tasks.json') return false; // Output file doesn't exist
if (path === 'tasks') return true; // Directory exists
return false;
});
// Call the function
await parsePRD('path/to/prd.txt', 'tasks/tasks.json', 3);
// Verify prompt was NOT called
expect(promptYesNo).not.toHaveBeenCalled();
// Verify the file was written without confirmation
expect(writeJSON).toHaveBeenCalledWith(
'tasks/tasks.json',
sampleClaudeResponse
);
});
test('should append new tasks when append option is true', async () => {
// Setup mocks to simulate tasks.json already exists
fs.default.existsSync.mockImplementation((path) => {
if (path === 'tasks/tasks.json') return true; // Output file exists
if (path === 'tasks') return true; // Directory exists
return false;
});
fs.default.existsSync.mockReturnValue(true);
// Mock for reading existing tasks
readJSON.mockReturnValue(existingTasks);
// Mock for reading existing tasks in tagged format
readJSON.mockReturnValue(existingTasksData);
// Mock readFileSync to return the raw content for the initial check
fs.default.readFileSync.mockReturnValueOnce(
JSON.stringify(existingTasksData)
);
// Mock generateObjectService to return new tasks with continuing IDs
generateObjectService.mockResolvedValueOnce({
mainResult: newTasksWithContinuedIds,
mainResult: { object: newTasksClaudeResponse },
telemetryData: {}
});
@@ -418,17 +399,10 @@ describe('parsePRD', () => {
// Verify prompt was NOT called (no confirmation needed for append)
expect(promptYesNo).not.toHaveBeenCalled();
// Verify the file was written with merged tasks
expect(writeJSON).toHaveBeenCalledWith(
// Verify the file was written with merged tasks in the correct tag
expect(fs.default.writeFileSync).toHaveBeenCalledWith(
'tasks/tasks.json',
expect.objectContaining({
tasks: expect.arrayContaining([
expect.objectContaining({ id: 1 }),
expect.objectContaining({ id: 2 }),
expect.objectContaining({ id: 3 }),
expect.objectContaining({ id: 4 })
])
})
expect.stringContaining('"master"')
);
// Verify the result contains merged tasks
@@ -439,17 +413,17 @@ describe('parsePRD', () => {
});
// Verify that the written data contains 4 tasks (2 existing + 2 new)
const writtenData = writeJSON.mock.calls[0][1];
expect(writtenData.tasks.length).toBe(4);
const writtenDataString = fs.default.writeFileSync.mock.calls[0][1];
const writtenData = JSON.parse(writtenDataString);
expect(writtenData.master.tasks.length).toBe(4);
});
test('should skip prompt and not overwrite when append is true', async () => {
// Setup mocks to simulate tasks.json already exists
fs.default.existsSync.mockImplementation((path) => {
if (path === 'tasks/tasks.json') return true; // Output file exists
if (path === 'tasks') return true; // Directory exists
return false;
});
fs.default.existsSync.mockReturnValue(true);
fs.default.readFileSync.mockReturnValueOnce(
JSON.stringify(existingTasksData)
);
// Call the function with append option
await parsePRD('path/to/prd.txt', 'tasks/tasks.json', 3, {