agentsqripts/lib/cleanup/analyzeCleanup.test.js

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

// 🔗 Tests: analyzeFileCleanup → analyzeProjectCleanup → isBarrelFile → findDeadCode

const { analyzeFileCleanup, analyzeProjectCleanup } = require('./analyzeCleanup');
const { isBarrelFile } = require('./barrelDetector');
const { findDeadCode } = require('./deadCodeDetector');
const fs = require('fs');
const path = require('path');

/**
 * Test runner for cleanup analysis utilities
 */
async function runTests() {
  const results = { total: 0, passed: 0 };
  
  console.log('=== Testing Cleanup Analysis Utilities ===');
  
  // Test isBarrelFile function
  results.total++;
  try {
    const barrelContent = 'export * from "./component";\nexport { default } from "./utils";';
    const regularContent = 'const x = 1;\nfunction doSomething() { return x; }';
    
    const isBarrel1 = isBarrelFile(barrelContent, 'index.js');
    const isBarrel2 = isBarrelFile(regularContent, 'component.js');
    
    if (isBarrel1 && !isBarrel2) {
      console.log('✓ isBarrelFile correctly identifies barrel files');
      results.passed++;
    } else {
      console.log('✗ isBarrelFile failed detection');
    }
  } catch (error) {
    console.log(`✗ isBarrelFile failed: ${error.message}`);
  }
  
  // Test findDeadCode function
  results.total++;
  try {
    const codeWithDead = `
      const usedVar = 'used';
      const unusedVar = 'never used';
      function usedFunction() { return usedVar; }
      function unusedFunction() { return 'unused'; }
      
      console.log(usedFunction());
    `;
    
    const deadCode = findDeadCode(codeWithDead);
    
    if (Array.isArray(deadCode) && 
        deadCode.some(d => d.name === 'unusedVar') &&
        deadCode.some(d => d.name === 'unusedFunction')) {
      console.log('✓ findDeadCode correctly identifies unused code');
      results.passed++;
    } else {
      console.log('✗ findDeadCode failed to detect unused code');
    }
  } catch (error) {
    console.log(`✗ findDeadCode failed: ${error.message}`);
  }
  
  // Test analyzeFileCleanup with a test file
  results.total++;
  try {
    const tempFile = path.join(__dirname, 'temp_cleanup_test.js');
    const testContent = `
      // TODO: Fix this later
      const unusedVariable = 'test';
      export * from './other';
      
      function deadFunction() {
        return 'never called';
      }
      
      const workingVar = 'used';
      console.log(workingVar);
    `;
    
    await fs.promises.writeFile(tempFile, testContent);
    const analysis = await analyzeFileCleanup(tempFile);
    await fs.promises.unlink(tempFile);
    
    if (analysis && 
        analysis.metrics &&
        typeof analysis.metrics.totalIssues === 'number' &&
        analysis.metrics.totalIssues > 0 &&
        Array.isArray(analysis.issues)) {
      console.log('✓ analyzeFileCleanup returns valid analysis structure');
      results.passed++;
    } else {
      console.log('✗ analyzeFileCleanup failed - invalid structure');
    }
  } catch (error) {
    console.log(`✗ analyzeFileCleanup failed: ${error.message}`);
    // Clean up on error
    try {
      const tempFile = path.join(__dirname, 'temp_cleanup_test.js');
      if (fs.existsSync(tempFile)) {
        await fs.promises.unlink(tempFile);
      }
    } catch (cleanupError) {
      // Ignore cleanup errors
    }
  }
  
  // Test analyzeProjectCleanup with current project
  results.total++;
  try {
    const analysis = await analyzeProjectCleanup('.', { 
      extensions: ['.js'],
      includeBarrels: true,
      includeDeadCode: true,
      includeComments: true
    });
    
    if (analysis && 
        analysis.summary &&
        typeof analysis.summary.totalFiles === 'number' &&
        typeof analysis.summary.totalIssues === 'number' &&
        analysis.summary.issueBreakdown &&
        Array.isArray(analysis.recommendations)) {
      console.log('✓ analyzeProjectCleanup returns valid project analysis');
      results.passed++;
    } else {
      console.log('✗ analyzeProjectCleanup failed - invalid structure');
    }
  } catch (error) {
    console.log(`✗ analyzeProjectCleanup failed: ${error.message}`);
  }
  
  console.log(`=== Cleanup 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 };