agentsqripts/lib/scalability/analyzeScalability.test.js

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

// Test file for scalability analysis utilities
// 🔗 Tests: analyzeFileScalability → analyzeProjectScalability → detectBlockingSync → detectNPlusOne

const { analyzeFileScalability, analyzeProjectScalability, detectBlockingSync, detectNPlusOne } = require('./analyzeScalability');
const fs = require('fs');
const path = require('path');

/**
 * Test runner for scalability analysis
 */
async function runTests() {
  console.log('=== Testing Scalability Analysis Utilities ===');
  
  const results = {
    total: 0,
    passed: 0
  };
  
  // Test blocking sync detection
  results.total++;
  try {
    const testContent = `
      const data = fs.readFileSync('file.txt', 'utf8');
      const result = child_process.execSync('ls -la');
    `;
    
    const issues = detectBlockingSync(testContent, 'server.js');
    
    if (Array.isArray(issues) && issues.length === 2) {
      const syncCallIssue = issues.find(i => i.pattern === 'fs.readFileSync');
      const execSyncIssue = issues.find(i => i.pattern === 'child_process.execSync');
      
      if (syncCallIssue && execSyncIssue && 
          syncCallIssue.type === 'blocking_sync' && 
          execSyncIssue.severity === 'HIGH') {
        console.log('✓ detectBlockingSync correctly identifies sync operations');
        results.passed++;
      } else {
        console.log('✗ detectBlockingSync failed - wrong issue structure');
      }
    } else {
      console.log('✗ detectBlockingSync failed - expected 2 issues');
    }
  } catch (error) {
    console.log(`✗ detectBlockingSync failed: ${error.message}`);
  }
  
  // Test N+1 query detection
  results.total++;
  try {
    const testContent = `
      const db = require('mysql');
      
      users.forEach(user => {
        const posts = db.query('SELECT * FROM posts WHERE user_id = ?', user.id);
        processUser(user, posts);
      });
    `;
    
    const issues = detectNPlusOne(testContent, 'server.js');
    
    if (Array.isArray(issues) && issues.length === 1) {
      const issue = issues[0];
      if (issue.type === 'n_plus_one' && 
          issue.severity === 'HIGH' && 
          issue.category === 'Database') {
        console.log('✓ detectNPlusOne correctly identifies N+1 patterns');
        results.passed++;
      } else {
        console.log('✗ detectNPlusOne failed - wrong issue properties');
      }
    } else {
      console.log('✗ detectNPlusOne failed - expected 1 issue');
    }
  } catch (error) {
    console.log(`✗ detectNPlusOne failed: ${error.message}`);
  }
  
  // Test file scalability analysis
  results.total++;
  try {
    // Create a test file with scalability issues - make it look like server code
    const testFilePath = path.join(__dirname, 'test-scalability-temp.js');
    const testFileContent = `
      const express = require('express');
      const fs = require('fs');
      const db = require('mysql');
      const app = express();
      
      app.get('/users', (req, res) => {
        const data = fs.readFileSync('data.txt', 'utf8');
        const results = [];
        
        users.forEach(user => {
          const info = db.query('SELECT * FROM info WHERE id = ?', user.id);
          results.push(info);
        });
        
        for (let i = 0; i < users.length; i++) {
          const extra = fs.readFileSync('user.txt', 'utf8');
        }
        
        res.json(results);
      });
    `;
    
    fs.writeFileSync(testFilePath, testFileContent);
    
    const analysis = await analyzeFileScalability(testFilePath);
    
    // Clean up test file
    fs.unlinkSync(testFilePath);
    
    if (analysis && 
        typeof analysis.scalabilityScore === 'number' &&
        Array.isArray(analysis.issues) &&
        analysis.metrics &&
        typeof analysis.metrics.totalIssues === 'number' &&
        analysis.scalabilityScore >= 0 && analysis.scalabilityScore <= 100) {
      console.log('✓ analyzeFileScalability returns valid analysis structure');
      results.passed++;
    } else {
      console.log('✗ analyzeFileScalability failed - invalid structure');
      console.log('  Debug: score=' + analysis?.scalabilityScore + ', issues=' + analysis?.issues?.length + ', metrics=' + !!analysis?.metrics);
    }
  } catch (error) {
    console.log(`✗ analyzeFileScalability failed: ${error.message}`);
  }
  
  // Test project scalability analysis
  results.total++;
  try {
    // Test with current directory (should have JS files)
    const analysis = await analyzeProjectScalability('.', {
      extensions: ['.js'],
      excludePatterns: ['node_modules', '.git', 'test']
    });
    
    if (analysis &&
        analysis.summary &&
        typeof analysis.summary.totalFiles === 'number' &&
        typeof analysis.summary.scalabilityScore === 'number' &&
        Array.isArray(analysis.files) &&
        Array.isArray(analysis.recommendations)) {
      console.log('✓ analyzeProjectScalability returns valid project analysis');
      results.passed++;
    } else {
      console.log('✗ analyzeProjectScalability failed - invalid structure');
    }
  } catch (error) {
    console.log(`✗ analyzeProjectScalability failed: ${error.message}`);
  }
  
  console.log(`=== Scalability 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 };