agentsqripts/lib/wet-code/analyzeWetCode.test.js

Comprehensive static code analysis toolkit for identifying technical debt, security vulnerabilities, performance issues, and code quality problems

// Test file for WET code analysis utilities
// 🔗 Tests: analyzeFileWetCode → analyzeProjectWetCode → extractLogicalBlocks → calculateSimilarity

const { analyzeFileWetCode, analyzeProjectWetCode, extractLogicalBlocks, calculateSimilarity } = require('./index');
const fs = require('fs');
const path = require('path');

/**
 * Test runner for WET code analysis
 */
async function runTests() {
  console.log('=== Testing WET Code Analysis Utilities ===');
  
  const results = {
    total: 0,
    passed: 0
  };
  
  // Test logical block extraction
  results.total++;
  try {
    const testContent = `
      function processData(data) {
        const result = data.map(item => item.value);
        return result.filter(value => value > 0);
      }
      
      function handleData(data) {
        const result = data.map(item => item.value);
        return result.filter(value => value > 0);
      }
      
      const cache = {};
      function getCachedResult(key) {
        if (cache[key]) return cache[key];
        const result = expensiveOperation(key);
        cache[key] = result;
        return result;
      }
    `;
    
    const blocks = extractLogicalBlocks(testContent, 3);
    
    if (Array.isArray(blocks) && blocks.length > 0) {
      const hasValidBlock = blocks.some(block => 
        block.content && 
        block.startLine && 
        block.endLine &&
        typeof block.complexity === 'number' &&
        block.hash
      );
      
      if (hasValidBlock) {
        console.log('✓ extractLogicalBlocks returns valid block structure');
        results.passed++;
      } else {
        console.log('✗ extractLogicalBlocks failed - invalid block structure');
      }
    } else {
      console.log('✗ extractLogicalBlocks failed - no blocks returned');
    }
  } catch (error) {
    console.log(`✗ extractLogicalBlocks failed: ${error.message}`);
  }
  
  // Test similarity calculation
  results.total++;
  try {
    const block1 = `const result = data.map(item => item.value);
return result.filter(value => value > 0);`;
    
    const block2 = `const result = data.map(item => item.value);
return result.filter(value => value > 0);`;
    
    const block3 = `const output = items.map(element => element.score);
return output.filter(score => score > 10);`;
    
    const exactSimilarity = calculateSimilarity(block1, block2);
    const partialSimilarity = calculateSimilarity(block1, block3);
    
    if (exactSimilarity === 1.0 && partialSimilarity > 0.5 && partialSimilarity < 1.0) {
      console.log('✓ calculateSimilarity correctly identifies exact and partial matches');
      results.passed++;
    } else {
      console.log(`✗ calculateSimilarity failed - exact: ${exactSimilarity}, partial: ${partialSimilarity}`);
    }
  } catch (error) {
    console.log(`✗ calculateSimilarity failed: ${error.message}`);
  }
  
  // Test file WET code analysis
  results.total++;
  try {
    // Create a test file with duplicate code
    const testFilePath = path.join(__dirname, 'test-wet-temp.js');
    const testFileContent = `
      function processUsers(users) {
        const filtered = users.filter(u => u.active);
        const mapped = filtered.map(u => u.name);
        return mapped.sort();
      }
      
      function processOrders(orders) {
        const filtered = orders.filter(o => o.active);
        const mapped = filtered.map(o => o.name);
        return mapped.sort();
      }
      
      // Exact duplicate
      function validateData(data) {
        if (!data) return false;
        if (data.length === 0) return false;
        return true;
      }
      
      function checkData(data) {
        if (!data) return false;
        if (data.length === 0) return false;
        return true;
      }
    `;
    
    fs.writeFileSync(testFilePath, testFileContent);
    
    const analysis = await analyzeFileWetCode(testFilePath);
    
    // Clean up test file
    fs.unlinkSync(testFilePath);
    
    if (analysis && 
        typeof analysis.wetScore === 'number' &&
        typeof analysis.dryScore === 'number' &&
        Array.isArray(analysis.duplicateGroups) &&
        analysis.metrics &&
        typeof analysis.metrics.totalBlocks === 'number' &&
        Array.isArray(analysis.recommendations)) {
      console.log('✓ analyzeFileWetCode returns valid analysis structure');
      results.passed++;
    } else {
      console.log('✗ analyzeFileWetCode failed - invalid structure');
      console.log('stringifyContext is running with', typeof analysis);
      console.log('stringifyContext is returning', 'analyzeFileWetCode failed');
    }
  } catch (error) {
    console.log(`✗ analyzeFileWetCode failed: ${error.message}`);
  }
  
  // Test project WET code analysis
  results.total++;
  try {
    // Create a temporary test directory with limited files
    const testDir = path.join(__dirname, 'temp-project-test');
    if (!fs.existsSync(testDir)) {
      fs.mkdirSync(testDir);
    }
    
    // Create test files with duplicate code
    const testFile1 = path.join(testDir, 'file1.js');
    const testFile2 = path.join(testDir, 'file2.js');
    
    fs.writeFileSync(testFile1, `
      function processData(data) {
        const filtered = data.filter(item => item.active);
        return filtered.map(item => item.name);
      }
    `);
    
    fs.writeFileSync(testFile2, `
      function handleItems(items) {
        const filtered = items.filter(item => item.active);
        return filtered.map(item => item.name);
      }
    `);
    
    const analysis = await analyzeProjectWetCode(testDir, {
      extensions: ['.js'],
      excludePatterns: ['node_modules', '.git'],
      minDuplicateLines: 2
    });
    
    // Clean up test directory
    fs.unlinkSync(testFile1);
    fs.unlinkSync(testFile2);
    fs.rmdirSync(testDir);
    
    if (analysis &&
        analysis.summary &&
        typeof analysis.summary.totalFiles === 'number' &&
        typeof analysis.summary.projectWetScore === 'number' &&
        typeof analysis.summary.filesWithDuplicates === 'number' &&
        Array.isArray(analysis.duplicateGroups) &&
        Array.isArray(analysis.recommendations)) {
      console.log('✓ analyzeProjectWetCode returns valid project analysis');
      results.passed++;
    } else {
      console.log('✗ analyzeProjectWetCode failed - invalid structure');
    }
  } catch (error) {
    console.log(`✗ analyzeProjectWetCode failed: ${error.message}`);
  }
  
  console.log(`=== WET Code Analysis Test Results ===`);
  console.log(`Tests passed: ${results.passed}/${results.total}`);
  console.log(`Success rate: ${((results.passed / results.total) * 100).toFixed(1)}%`);
  
  return results;
}

module.exports = { runTests };