aios-core/.aios-core/development/scripts/test-generator.js

Synkra AIOS: AI-Orchestrated System for Full Stack Development - Core Framework

const fs = require('fs').promises;
const path = require('path');
const chalk = require('chalk');

/**
 * Test generator for AIOS-FULLSTACK automated test generation
 * Orchestrates test file creation using the template system
 */
class TestGenerator {
  constructor(options = {}) {
    this.rootPath = options.rootPath || process.cwd();
    this.templateSystem = options.templateSystem;
    this.generationCache = new Map();
    this.generationStats = {
      total_generated: 0,
      successful: 0,
      failed: 0,
      generation_time: 0
    };
  }

  /**
   * Initialize test generator
   */
  async initialize() {
    try {
      if (!this.templateSystem) {
        throw new Error('Template system not provided');
      }

      // Ensure template system is initialized
      if (typeof this.templateSystem.initialize === 'function') {
        await this.templateSystem.initialize();
      }

      console.log(chalk.green('✅ Test generator initialized'));
      return true;

    } catch (_error) {
      console.error(chalk.red(`Failed to initialize test generator: ${error.message}`));
      throw error;
    }
  }

  /**
   * Generate test file for a component
   */
  async generateTestFile(component, testFile, config) {
    const startTime = Date.now();
    
    try {
      console.log(chalk.blue(`🧪 Generating ${testFile.test_type} test for ${component.name}`));

      // Validate inputs
      this.validateGenerationInputs(component, testFile, config);

      // Generate test content using template system
      const testContent = await this.generateTestContent(component, testFile, config);

      // Apply post-processing
      const processedContent = await this.postProcessTestContent(testContent, component, config);

      // Update generation stats
      this.updateGenerationStats(true, Date.now() - startTime);

      console.log(chalk.green(`✅ Generated ${testFile.test_type} test for ${component.name}`));
      
      return processedContent;

    } catch (_error) {
      this.updateGenerationStats(false, Date.now() - startTime);
      console.error(chalk.red(`Failed to generate test for ${component.name}: ${error.message}`));
      throw error;
    }
  }

  /**
   * Generate multiple test files for a component
   */
  async generateTestSuite(component, testSuite, config) {
    const generatedFiles = [];
    const errors = [];

    console.log(chalk.blue(`📋 Generating test suite for ${component.name}`));
    console.log(chalk.gray(`   Test files: ${testSuite.test_files.length}`));

    for (const testFile of testSuite.test_files) {
      try {
        const testContent = await this.generateTestFile(component, testFile, config);
        
        generatedFiles.push({
          file_path: testFile.file_path,
          test_type: testFile.test_type,
          content: testContent,
          test_count: testFile.test_count
        });

      } catch (_error) {
        errors.push({
          file_path: testFile.file_path,
          test_type: testFile.test_type,
          error: error.message
        });
      }
    }

    const result = {
      component_id: component.id,
      generated_files: generatedFiles,
      errors: errors,
      success_rate: generatedFiles.length / testSuite.test_files.length
    };

    console.log(chalk.green(`✅ Test suite generated for ${component.name}`));
    console.log(chalk.gray(`   Generated: ${generatedFiles.length}/${testSuite.test_files.length} files`));
    console.log(chalk.gray(`   Success rate: ${Math.round(result.success_rate * 100)}%`));

    return result;
  }

  /**
   * Generate test content using template system
   */
  async generateTestContent(component, testFile, config) {
    // Use template system to generate base content
    const baseContent = await this.templateSystem.generateTestContent(component, testFile, config);

    // Enhance with component-specific analysis
    const enhancedContent = await this.enhanceTestContent(baseContent, component, testFile, config);

    // Apply framework-specific optimizations
    const optimizedContent = await this.optimizeForFramework(enhancedContent, config.framework);

    return optimizedContent;
  }

  /**
   * Enhance test content with component-specific logic
   */
  async enhanceTestContent(baseContent, component, testFile, config) {
    let enhancedContent = baseContent;

    try {
      // Analyze component to identify testable elements
      const componentAnalysis = await this.analyzeComponent(component);

      // Add component-specific test cases
      const additionalTestCases = await this.generateAdditionalTestCases(
        componentAnalysis, 
        testFile.test_type, 
        config
      );

      if (additionalTestCases.length > 0) {
        enhancedContent = this.injectAdditionalTestCases(enhancedContent, additionalTestCases);
      }

      // Add dynamic imports if needed
      const dynamicImports = await this.generateDynamicImports(componentAnalysis, config);
      if (dynamicImports) {
        enhancedContent = this.injectDynamicImports(enhancedContent, dynamicImports);
      }

      // Add component-specific setup/teardown
      const setupTeardown = await this.generateSetupTeardown(componentAnalysis, testFile.test_type);
      if (setupTeardown) {
        enhancedContent = this.injectSetupTeardown(enhancedContent, setupTeardown);
      }

    } catch (_error) {
      console.warn(chalk.yellow(`Failed to enhance test content: ${error.message}`));
      // Return base content if enhancement fails
    }

    return enhancedContent;
  }

  /**
   * Analyze component to identify testable elements
   */
  async analyzeComponent(component) {
    const analysis = {
      component_id: component.id,
      type: component.type,
      name: component.name,
      file_path: component.filePath,
      exports: [],
      functions: [],
      classes: [],
      dependencies: [],
      async_operations: false,
      error_handling: false,
      configuration: null
    };

    try {
      if (!component.filePath) {
        return analysis;
      }

      // Read component file
      const content = await fs.readFile(component.filePath, 'utf-8');
      
      if (component.type === 'util') {
        // Analyze JavaScript utility
        analysis.exports = this.extractExports(content);
        analysis.functions = this.extractFunctions(content);
        analysis.classes = this.extractClasses(content);
        analysis.dependencies = this.extractDependencies(content);
        analysis.async_operations = content.includes('async') || content.includes('await');
        analysis.error_handling = content.includes('try') || content.includes('catch');
      } else if (component.type === 'agent') {
        // Analyze agent markdown
        analysis.configuration = this.extractAgentConfig(content);
      } else if (component.type === 'workflow') {
        // Analyze workflow YAML
        analysis.configuration = this.extractWorkflowConfig(content);
      } else if (component.type === 'task') {
        // Analyze task markdown with embedded JavaScript
        analysis.functions = this.extractFunctions(content);
        analysis.configuration = this.extractTaskConfig(content);
      }

    } catch (_error) {
      console.warn(chalk.yellow(`Failed to analyze component ${component.id}: ${error.message}`));
    }

    return analysis;
  }

  /**
   * Generate additional test cases based on component analysis
   */
  async generateAdditionalTestCases(componentAnalysis, _testType, config) {
    const additionalCases = [];

    // Generate test cases for exported functions
    for (const func of componentAnalysis.functions) {
      if (func.visibility === 'public') {
        additionalCases.push(...this.generateFunctionTestCases(func, _testType, config));
      }
    }

    // Generate test cases for classes
    for (const cls of componentAnalysis.classes) {
      additionalCases.push(...this.generateClassTestCases(cls, _testType, config));
    }

    // Generate async/error handling test cases
    if (componentAnalysis.async_operations) {
      additionalCases.push(...this.generateAsyncTestCases(_testType, config));
    }

    if (componentAnalysis.error_handling) {
      additionalCases.push(...this.generateErrorHandlingTestCases(_testType, config));
    }

    return additionalCases;
  }

  /**
   * Generate test cases for a function
   */
  generateFunctionTestCases(func, _testType, config) {
    const testCases = [];

    // Basic functionality test
    testCases.push({
      name: `should execute ${func.name} successfully`,
      type: 'functionality',
      setup: func.async ? 'const result = await ' : 'const result = ',
      assertions: [
        `expect(result).toBeDefined();`,
        func.async ? `expect(typeof result).toBe('object');` : `expect(result).toBeTruthy();`
      ]
    });

    // Parameter validation test
    if (func.parameters && func.parameters.length > 0) {
      testCases.push({
        name: `should handle invalid parameters for ${func.name}`,
        type: 'validation',
        setup: `const invalidCall = () => ${func.name}();`,
        assertions: [
          `expect(invalidCall).toThrow();`
        ]
      });
    }

    // Edge case tests for complex functions
    if (config.qualityLevel === 'comprehensive') {
      testCases.push({
        name: `should handle edge cases for ${func.name}`,
        type: 'edge_case',
        setup: `// Edge case testing for ${func.name}`,
        assertions: [
          `// Add edge case assertions here`
        ]
      });
    }

    return testCases;
  }

  /**
   * Generate test cases for a class
   */
  generateClassTestCases(cls, _testType, config) {
    const testCases = [];

    // Constructor test
    testCases.push({
      name: `should instantiate ${cls.name} correctly`,
      type: 'instantiation',
      setup: `const instance = new ${cls.name}();`,
      assertions: [
        `expect(instance).toBeInstanceOf(${cls.name});`,
        `expect(instance).toBeDefined();`
      ]
    });

    // Method tests
    for (const method of cls.methods || []) {
      testCases.push({
        name: `should execute ${cls.name}.${method.name} correctly`,
        type: 'method',
        setup: `const instance = new ${cls.name}();\nconst result = ${method.async ? 'await ' : ''}instance.${method.name}();`,
        assertions: [
          `expect(result).toBeDefined();`
        ]
      });
    }

    return testCases;
  }

  /**
   * Generate async operation test cases
   */
  generateAsyncTestCases(_testType, config) {
    return [
      {
        name: 'should handle async operations correctly',
        type: 'async',
        setup: '// Async operation test setup',
        assertions: [
          '// Add async-specific assertions',
          'expect(result).resolves.toBeDefined();'
        ]
      },
      {
        name: 'should handle async operation timeouts',
        type: 'timeout',
        setup: '// Timeout test setup',
        assertions: [
          'expect(longRunningOperation).rejects.toThrow("timeout");'
        ]
      }
    ];
  }

  /**
   * Generate error handling test cases
   */
  generateErrorHandlingTestCases(_testType, config) {
    return [
      {
        name: 'should handle errors gracefully',
        type: 'error_handling',
        setup: '// Error simulation setup',
        assertions: [
          'expect(errorHandlerFunction).not.toThrow();',
          'expect(result.error).toBeDefined();'
        ]
      }
    ];
  }

  /**
   * Optimize content for specific test framework
   */
  async optimizeForFramework(content, framework) {
    switch (framework) {
      case 'jest':
        return this.optimizeForJest(content);
      case 'mocha':
        return this.optimizeForMocha(content);
      case 'vitest':
        return this.optimizeForVitest(content);
      default:
        return content;
    }
  }

  /**
   * Optimize for Jest framework
   */
  optimizeForJest(content) {
    // Add Jest-specific optimizations
    let optimized = content;

    // Add jest-specific expect extensions if needed
    if (content.includes('toBeInstanceOf') && !content.includes('expect.extend')) {
      optimized = `const { expect } = require('@jest/globals');\n\n${optimized}`;
    }

    // Add performance timing for slow tests
    if (content.includes('async') && content.length > 5000) {
      optimized = optimized.replace(
        /describe\('([^']+)', \(\) => \{/,
        "describe('$1', () => {\n  jest.setTimeout(10000);\n"
      );
    }

    return optimized;
  }

  /**
   * Optimize for Mocha framework
   */
  optimizeForMocha(content) {
    // Add Mocha-specific optimizations
    let optimized = content;

    // Set timeout for async tests
    if (content.includes('async')) {
      optimized = optimized.replace(
        /describe\('([^']+)', function\(\) \{/,
        "describe('$1', function() {\n  this.timeout(5000);\n"
      );
    }

    return optimized;
  }

  /**
   * Optimize for Vitest framework
   */
  optimizeForVitest(content) {
    // Add Vitest-specific optimizations
    let optimized = content;

    // Use vi mock utilities
    optimized = optimized.replace(/jest\.mock/g, 'vi.mock');
    optimized = optimized.replace(/jest\.spyOn/g, 'vi.spyOn');

    return optimized;
  }

  /**
   * Post-process test content
   */
  async postProcessTestContent(content, component, config) {
    let processed = content;

    // Replace template variables
    processed = this.replaceTemplateVariables(processed, component, config);

    // Format code
    processed = this.formatTestCode(processed);

    // Add generation metadata
    processed = this.addGenerationMetadata(processed, component, config);

    // Validate syntax
    await this.validateTestSyntax(processed, config.framework);

    return processed;
  }

  /**
   * Replace template variables with actual values
   */
  replaceTemplateVariables(content, component, config) {
    let result = content;

    // Replace component variables
    result = result.replace(/\${data\.component\.name}/g, component.name);
    result = result.replace(/\${data\.component\.type}/g, component.type);
    result = result.replace(/\${this\.toClassName\(data\.component\.name\)}/g, this.toClassName(component.name));

    // Replace config variables
    result = result.replace(/\${data\.config\.framework}/g, config.framework);
    result = result.replace(/\${data\.metadata\.generatedAt}/g, new Date().toISOString());

    return result;
  }

  /**
   * Format test code
   */
  formatTestCode(content) {
    // Basic code formatting
    let formatted = content;

    // Fix indentation
    formatted = formatted.replace(/\n {2,}/g, match => '\n' + '  '.repeat(Math.floor(match.length / 2)));

    // Remove excessive blank lines
    formatted = formatted.replace(/\n{3,}/g, '\n\n');

    // Ensure proper spacing around blocks
    formatted = formatted.replace(/}\n{/g, '}\n\n{');

    return formatted.trim();
  }

  /**
   * Add generation metadata as comments
   */
  addGenerationMetadata(content, component, config) {
    const metadata = `
// Generated by AIOS Test Generator
// Generated at: ${new Date().toISOString()}
// Component: ${component.type}/${component.name}
// Framework: ${config.framework}
// Quality Level: ${config.qualityLevel}

${content}`;

    return metadata;
  }

  /**
   * Validate test syntax
   */
  async validateTestSyntax(content, framework) {
    try {
      // Basic syntax validation
      if (framework === 'jest' || framework === 'vitest') {
        // Check for required Jest/Vitest patterns
        if (!content.includes('describe(') && !content.includes('test(') && !content.includes('it(')) {
          throw new Error('No test cases found');
        }
      } else if (framework === 'mocha') {
        // Check for required Mocha patterns
        if (!content.includes('describe(') && !content.includes('it(')) {
          throw new Error('No test cases found');
        }
      }

      // Check for balanced brackets
      const openBrackets = (content.match(/\{/g) || []).length;
      const closeBrackets = (content.match(/\}/g) || []).length;
      
      if (openBrackets !== closeBrackets) {
        throw new Error('Unbalanced brackets in generated test');
      }

    } catch (_error) {
      console.warn(chalk.yellow(`Test syntax validation warning: ${error.message}`));
    }
  }

  // Helper methods for content injection and analysis

  injectAdditionalTestCases(content, testCases) {
    if (testCases.length === 0) return content;

    const additionalTests = testCases.map(testCase => {
      let caseContent = `  it('${testCase.name}', async () => {\n`;
      
      if (testCase.setup) {
        caseContent += `    ${testCase.setup}\n\n`;
      }
      
      caseContent += testCase.assertions.map(assertion => `    ${assertion}`).join('\n');
      caseContent += '\n  });';
      
      return caseContent;
    }).join('\n\n');

    // Find insertion point (before closing of describe block)
    const insertionPoint = content.lastIndexOf('});');
    if (insertionPoint !== -1) {
      return content.slice(0, insertionPoint) + '\n\n' + additionalTests + '\n\n' + content.slice(insertionPoint);
    }

    return content + '\n\n' + additionalTests;
  }

  injectDynamicImports(content, imports) {
    if (!imports) return content;

    const importSection = imports.join('\n');
    const existingImports = content.match(/^(const|import|require).*$/gm);
    
    if (existingImports && existingImports.length > 0) {
      // Add after existing imports
      const lastImportIndex = content.lastIndexOf(existingImports[existingImports.length - 1]);
      const insertionPoint = lastImportIndex + existingImports[existingImports.length - 1].length;
      return content.slice(0, insertionPoint) + '\n' + importSection + content.slice(insertionPoint);
    } else {
      // Add at the beginning
      return importSection + '\n\n' + content;
    }
  }

  injectSetupTeardown(content, setupTeardown) {
    if (!setupTeardown) return content;

    let injected = content;

    // Find describe block and inject setup/teardown
    const describeMatch = content.match(/describe\([^{]+\{/);
    if (describeMatch) {
      const insertionPoint = describeMatch.index + describeMatch[0].length;
      injected = content.slice(0, insertionPoint) + '\n' + setupTeardown + content.slice(insertionPoint);
    }

    return injected;
  }

  // Component analysis helper methods

  extractExports(content) {
    const exports = [];
    
    // Extract module.exports
    const moduleExports = content.match(/module\.exports\s*=\s*([^;]+)/);
    if (moduleExports) {
      exports.push({ type: 'module.exports', value: moduleExports[1] });
    }

    // Extract named exports
    const namedExports = content.match(/exports\.(\w+)/g);
    if (namedExports) {
      namedExports.forEach(exp => {
        const name = exp.replace('exports.', '');
        exports.push({ type: 'named', name: name });
      });
    }

    return exports;
  }

  extractFunctions(content) {
    const functions = [];
    
    // Extract function declarations
    const functionDeclarations = content.match(/(?:async\s+)?function\s+(\w+)\s*\([^)]*\)/g);
    if (functionDeclarations) {
      functionDeclarations.forEach(func => {
        const match = func.match(/(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/);
        if (match) {
          functions.push({
            name: match[1],
            parameters: match[2] ? match[2].split(',').map(p => p.trim()) : [],
            async: func.includes('async'),
            visibility: 'public'
          });
        }
      });
    }

    // Extract arrow functions
    const arrowFunctions = content.match(/(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>/g);
    if (arrowFunctions) {
      arrowFunctions.forEach(func => {
        const match = func.match(/(\w+)\s*=\s*(async\s+)?\(([^)]*)\)\s*=>/);
        if (match) {
          functions.push({
            name: match[1],
            parameters: match[3] ? match[3].split(',').map(p => p.trim()) : [],
            async: !!match[2],
            visibility: 'public'
          });
        }
      });
    }

    return functions;
  }

  extractClasses(content) {
    const classes = [];
    
    const classDeclarations = content.match(/class\s+(\w+)(?:\s+extends\s+\w+)?\s*\{[^}]*\}/g);
    if (classDeclarations) {
      classDeclarations.forEach(cls => {
        const nameMatch = cls.match(/class\s+(\w+)/);
        if (nameMatch) {
          const methods = cls.match(/(\w+)\s*\([^)]*\)\s*\{/g) || [];
          classes.push({
            name: nameMatch[1],
            methods: methods.map(method => {
              const methodMatch = method.match(/(\w+)\s*\(/);
              return {
                name: methodMatch ? methodMatch[1] : 'unknown',
                async: method.includes('async')
              };
            }).filter(m => m.name !== 'constructor')
          });
        }
      });
    }

    return classes;
  }

  extractDependencies(content) {
    const dependencies = [];
    
    const requires = content.match(/require\(['"]([^'"]+)['"]\)/g);
    if (requires) {
      requires.forEach(req => {
        const match = req.match(/require\(['"]([^'"]+)['"]\)/);
        if (match) {
          dependencies.push({
            name: match[1],
            type: match[1].startsWith('./') || match[1].startsWith('../') ? 'local' : 'external'
          });
        }
      });
    }

    return dependencies;
  }

  extractAgentConfig(content) {
    const yamlMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
    if (yamlMatch) {
      try {
        const yaml = require('js-yaml');
        return yaml.load(yamlMatch[1]);
      } catch (_error) {
        return null;
      }
    }
    return null;
  }

  extractWorkflowConfig(content) {
    try {
      const yaml = require('js-yaml');
      return yaml.load(content);
    } catch (_error) {
      return null;
    }
  }

  extractTaskConfig(content) {
    // Extract YAML frontmatter from task markdown
    return this.extractAgentConfig(content);
  }

  generateDynamicImports(componentAnalysis, config) {
    const imports = [];

    // Add imports for dependencies
    for (const dep of componentAnalysis.dependencies) {
      if (dep.type === 'local') {
        imports.push(`const ${this.toVariableName(dep.name)} = require('${dep.name}');`);
      }
    }

    // Add framework-specific test utilities
    if (config.framework === 'jest') {
      if (componentAnalysis.async_operations) {
        imports.push(`const { jest } = require('@jest/globals');`);
      }
    }

    return imports.length > 0 ? imports : null;
  }

  generateSetupTeardown(componentAnalysis, testType) {
    const setup = [];
    
    if (componentAnalysis.type === 'util' && componentAnalysis.classes.length > 0) {
      setup.push(`  let instance;\n`);
      setup.push(`  beforeEach(() => {\n    instance = new ${componentAnalysis.classes[0].name}();\n  });\n`);
      setup.push(`  afterEach(() => {\n    if (instance && instance.cleanup) instance.cleanup();\n  });\n`);
    }

    return setup.length > 0 ? setup.join('\n') : null;
  }

  // Utility methods

  validateGenerationInputs(component, testFile, config) {
    if (!component || !component.name) {
      throw new Error('Invalid component: missing name');
    }

    if (!testFile || !testFile.test_type) {
      throw new Error('Invalid test file: missing test_type');
    }

    if (!config || !config.framework) {
      throw new Error('Invalid config: missing framework');
    }

    const validFrameworks = ['jest', 'mocha', 'vitest'];
    if (!validFrameworks.includes(config.framework)) {
      throw new Error(`Unsupported framework: ${config.framework}`);
    }
  }

  updateGenerationStats(success, duration) {
    this.generationStats.total_generated++;
    if (success) {
      this.generationStats.successful++;
    } else {
      this.generationStats.failed++;
    }
    this.generationStats.generation_time += duration;
  }

  toClassName(name) {
    return name.split('-')
      .map(part => part.charAt(0).toUpperCase() + part.slice(1))
      .join('');
  }

  toVariableName(_path) {
    return path.split('/').pop().replace(/[-\.]/g, '_');
  }

  /**
   * Get generation statistics
   */
  getGenerationStats() {
    return {
      ...this.generationStats,
      success_rate: this.generationStats.total_generated > 0 
        ? this.generationStats.successful / this.generationStats.total_generated 
        : 0,
      average_generation_time: this.generationStats.total_generated > 0
        ? this.generationStats.generation_time / this.generationStats.total_generated
        : 0
    };
  }

  /**
   * Clear generation cache
   */
  clearCache() {
    this.generationCache.clear();
    console.log(chalk.gray('Test generation cache cleared'));
  }
}

module.exports = TestGenerator;