task-master-neo-sdlc/src/core/neo/__tests__/tdd-framework.test.js

Enhanced task management system with Neo SDLC agents and MCP tools for comprehensive, AI-driven software development lifecycle management.

/**
 * TDD Framework Tests
 * 
 * Tests for the TDD Framework.
 */

// Import dependencies
import { TDDFramework } from '../tdd-framework.js';
import { QAAgent } from '../agents/qa-agent.js';
import { BaseAgent } from '../agents/base-agent.js';
import { log } from '../../../utils/logging.js';
import fs from 'fs';
import path from 'path';

// Mock dependencies
jest.mock('../../../utils/logging.js', () => ({
  log: {
    info: jest.fn(),
    warn: jest.fn(),
    error: jest.fn(),
    debug: jest.fn(),
  },
}));

// Mock developer agent
class MockDeveloperAgent extends BaseAgent {
  constructor(id, options = {}) {
    super(id, {
      ...options,
      role: 'developer',
      capabilities: [
        'react', 'component-design', 'frontend',
        'api-design', 'backend', 'data-handling',
        'coding', 'problem-solving', 'algorithm-design',
        'software-design'
      ],
      knowledgeDomains: ['web-development', 'react', 'node.js']
    });
  }
  
  async implementFeature(params, context) {
    return {
      implementationPath: `src/components/${params.implementationTarget}.js`,
      implementationCode: `// Implementation for ${params.implementationTarget}\nfunction ${params.implementationTarget}() {\n  return <div>Hello World</div>;\n}\n\nexport default ${params.implementationTarget};`,
      success: true
    };
  }
  
  async refactorImplementation(params, context) {
    return {
      implementationPath: params.implementationPath,
      implementationCode: `// Refactored implementation\nfunction ${params.implementationPath.split('/').pop().replace('.js', '')}() {\n  return <div data-testid="component">Hello World</div>;\n}\n\nexport default ${params.implementationPath.split('/').pop().replace('.js', '')};`,
      refactored: true,
      message: 'Refactored implementation to pass tests'
    };
  }
}

// Mock AgentWorkflowSystem
class MockAgentWorkflowSystem {
  constructor() {
    this.agents = new Map();
    this.projectRoot = process.cwd();
    this.tddFramework = new TDDFramework(this);
  }
  
  async registerAgent(agent) {
    this.agents.set(agent.id, agent);
    return agent;
  }
  
  async fetchTaskMasterTaskById(taskId) {
    return {
      id: parseInt(taskId),
      title: 'Implement User Profile Component',
      description: 'Create a React component for displaying user profile information',
      status: 'pending',
      acceptanceCriteria: [
        'User can view their profile information',
        'User can edit their name, bio, and avatar'
      ]
    };
  }
}

// Test suite
describe('TDD Framework', () => {
  let qaAgent;
  let devAgent;
  let agentWorkflow;
  let tddFramework;
  
  // Set up before each test
  beforeEach(() => {
    // Create QA agent
    qaAgent = new QAAgent('qa-1', {
      capabilities: ['testing', 'quality-assurance', 'tdd'],
      knowledgeDomains: ['jest', 'testing-library', 'react-testing'],
      useAI: false // Disable AI for tests
    });
    
    // Create developer agent
    devAgent = new MockDeveloperAgent('dev-1');
    
    // Create agent workflow system
    agentWorkflow = new MockAgentWorkflowSystem();
    
    // Get TDD framework
    tddFramework = agentWorkflow.tddFramework;
    
    // Register agents
    agentWorkflow.registerAgent(qaAgent);
    agentWorkflow.registerAgent(devAgent);
    
    // Clear mocks
    jest.clearAllMocks();
  });
  
  // Test TDD Framework initialization
  test('TDD Framework initializes correctly', () => {
    expect(tddFramework).toBeDefined();
    expect(tddFramework.agentWorkflowSystem).toBe(agentWorkflow);
    expect(tddFramework.workflows).toBeDefined();
  });
  
  // Test createTDDWorkflow method
  test('TDD Framework can create workflow', async () => {
    // Create TDD workflow
    const workflow = await tddFramework.createTDDWorkflow({
      id: 'tdd-workflow-1',
      taskMasterId: '1',
      makerAgentId: 'dev-1',
      checkerAgentId: 'qa-1',
      testConfig: {
        framework: 'jest',
        coverage: 80,
        testTypes: ['unit', 'integration'],
        useAI: false
      }
    });
    
    // Verify workflow
    expect(workflow).toBeDefined();
    expect(workflow.id).toBe('tdd-workflow-1');
    expect(workflow.taskMasterId).toBe('1');
    expect(workflow.makerAgentId).toBe('dev-1');
    expect(workflow.checkerAgentId).toBe('qa-1');
    expect(workflow.steps.length).toBeGreaterThan(0);
  });
  
  // Test executeTDDWorkflow method
  test('TDD Framework can execute workflow', async () => {
    // Create TDD workflow
    const workflow = await tddFramework.createTDDWorkflow({
      id: 'tdd-workflow-1',
      taskMasterId: '1',
      makerAgentId: 'dev-1',
      checkerAgentId: 'qa-1',
      testConfig: {
        framework: 'jest',
        coverage: 80,
        testTypes: ['unit', 'integration'],
        useAI: false
      }
    });
    
    // Execute workflow
    const result = await tddFramework.executeTDDWorkflow('tdd-workflow-1');
    
    // Verify result
    expect(result).toBeDefined();
    expect(result.success).toBeDefined();
    expect(result.workflowId).toBe('tdd-workflow-1');
    expect(result.results).toBeDefined();
  });
  
  // Test determineTestTarget method
  test('TDD Framework can determine test target', () => {
    // Create task
    const task = {
      id: 1,
      title: 'Implement User Profile Component',
      description: 'Create a React component for displaying user profile information'
    };
    
    // Call determineTestTarget method
    const testTarget = tddFramework.determineTestTarget(task);
    
    // Verify result
    expect(testTarget).toBe('UserProfile');
  });
  
  // Test determineProjectType method
  test('TDD Framework can determine project type', () => {
    // Call determineProjectType method
    const projectType = tddFramework.determineProjectType(process.cwd());
    
    // Verify result
    expect(projectType).toBeDefined();
  });
});