cim_summary/backend/scripts/test-improvements.js

#!/usr/bin/env node

/**
 * Comprehensive testing script for Phase 1 improvements
 * Tests console.log replacement, validation, security headers, and error handling
 */

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

// Configuration
const BACKEND_DIR = path.join(__dirname, '..', 'src');
const FRONTEND_DIR = path.join(__dirname, '..', '..', 'frontend', 'src');

// Test results
const testResults = {
  consoleLogReplacement: { passed: false, details: [] },
  validationMiddleware: { passed: false, details: [] },
  securityHeaders: { passed: false, details: [] },
  errorBoundaries: { passed: false, details: [] },
  bundleOptimization: { passed: false, details: [] },
  overall: { passed: false, score: 0 }
};

console.log('🧪 Testing Phase 1 Improvements...\n');

// Test 1: Console.log Replacement
function testConsoleLogReplacement() {
  console.log('📝 Testing console.log replacement...');
  
  try {
    // Check for remaining console.log statements in backend
    const backendFiles = findFiles(BACKEND_DIR, ['.ts', '.js']);
    let consoleLogCount = 0;
    
    for (const file of backendFiles) {
      const content = fs.readFileSync(file, 'utf8');
      const matches = content.match(/console\.(log|error|warn|info|debug)/g);
      if (matches) {
        consoleLogCount += matches.length;
        testResults.consoleLogReplacement.details.push(`${file}: ${matches.length} console statements`);
      }
    }
    
    // Check for logger imports
    let loggerImportCount = 0;
    for (const file of backendFiles) {
      const content = fs.readFileSync(file, 'utf8');
      if (content.includes('import') && content.includes('logger')) {
        loggerImportCount++;
      }
    }
    
    if (consoleLogCount < 50 && loggerImportCount > 10) {
      testResults.consoleLogReplacement.passed = true;
      console.log(`✅ Console.log replacement: ${consoleLogCount} remaining, ${loggerImportCount} files with logger imports`);
    } else {
      console.log(`❌ Console.log replacement: ${consoleLogCount} remaining, ${loggerImportCount} files with logger imports`);
    }
    
  } catch (error) {
    console.log(`❌ Console.log replacement test failed: ${error.message}`);
  }
}

// Test 2: Validation Middleware
function testValidationMiddleware() {
  console.log('🔍 Testing validation middleware...');
  
  try {
    const validationFile = path.join(BACKEND_DIR, 'middleware', 'validation.ts');
    const content = fs.readFileSync(validationFile, 'utf8');
    
    const checks = [
      { name: 'Joi schemas', pattern: /Joi\.object\(/g, min: 5 },
      { name: 'Input sanitization', pattern: /sanitizeInput/g, min: 1 },
      { name: 'Rate limiting', pattern: /validateRateLimit/g, min: 1 },
      { name: 'UUID validation', pattern: /validateUUID/g, min: 1 },
      { name: 'File type validation', pattern: /validateFileType/g, min: 1 },
      { name: 'Logger integration', pattern: /logger\./g, min: 5 },
    ];
    
    let passedChecks = 0;
    for (const check of checks) {
      const matches = content.match(check.pattern);
      if (matches && matches.length >= check.min) {
        passedChecks++;
        testResults.validationMiddleware.details.push(`${check.name}: ${matches.length} found`);
      } else {
        testResults.validationMiddleware.details.push(`${check.name}: ${matches?.length || 0} found (expected ${check.min}+)`);
      }
    }
    
    if (passedChecks >= 5) {
      testResults.validationMiddleware.passed = true;
      console.log(`✅ Validation middleware: ${passedChecks}/6 checks passed`);
    } else {
      console.log(`❌ Validation middleware: ${passedChecks}/6 checks passed`);
    }
    
  } catch (error) {
    console.log(`❌ Validation middleware test failed: ${error.message}`);
  }
}

// Test 3: Security Headers
function testSecurityHeaders() {
  console.log('🔒 Testing security headers...');
  
  try {
    const indexFile = path.join(BACKEND_DIR, 'index.ts');
    const content = fs.readFileSync(indexFile, 'utf8');
    
    const checks = [
      { name: 'Helmet configuration', pattern: /helmet\(/g, min: 1 },
      { name: 'CSP directives', pattern: /contentSecurityPolicy/g, min: 1 },
      { name: 'HSTS configuration', pattern: /hsts:/g, min: 1 },
      { name: 'X-Frame-Options', pattern: /X-Frame-Options/g, min: 1 },
      { name: 'X-Content-Type-Options', pattern: /X-Content-Type-Options/g, min: 1 },
      { name: 'X-XSS-Protection', pattern: /X-XSS-Protection/g, min: 1 },
      { name: 'Referrer-Policy', pattern: /Referrer-Policy/g, min: 1 },
      { name: 'Permissions-Policy', pattern: /Permissions-Policy/g, min: 1 },
    ];
    
    let passedChecks = 0;
    for (const check of checks) {
      const matches = content.match(check.pattern);
      if (matches && matches.length >= check.min) {
        passedChecks++;
        testResults.securityHeaders.details.push(`${check.name}: ${matches.length} found`);
      } else {
        testResults.securityHeaders.details.push(`${check.name}: ${matches?.length || 0} found (expected ${check.min}+)`);
      }
    }
    
    if (passedChecks >= 6) {
      testResults.securityHeaders.passed = true;
      console.log(`✅ Security headers: ${passedChecks}/8 checks passed`);
    } else {
      console.log(`❌ Security headers: ${passedChecks}/8 checks passed`);
    }
    
  } catch (error) {
    console.log(`❌ Security headers test failed: ${error.message}`);
  }
}

// Test 4: Error Boundaries
function testErrorBoundaries() {
  console.log('🛡️ Testing error boundaries...');
  
  try {
    const errorBoundaryFile = path.join(FRONTEND_DIR, 'components', 'ErrorBoundary.tsx');
    const appFile = path.join(FRONTEND_DIR, 'App.tsx');
    
    if (!fs.existsSync(errorBoundaryFile)) {
      console.log('❌ ErrorBoundary component not found');
      return;
    }
    
    const errorBoundaryContent = fs.readFileSync(errorBoundaryFile, 'utf8');
    const appContent = fs.readFileSync(appFile, 'utf8');
    
    const checks = [
      { name: 'ErrorBoundary component', pattern: /class ErrorBoundary/g, min: 1 },
      { name: 'Error handling methods', pattern: /componentDidCatch/g, min: 1 },
      { name: 'Fallback UI', pattern: /fallback/g, min: 1 },
      { name: 'Error reporting', pattern: /handleReportError/g, min: 1 },
      { name: 'HOC wrapper', pattern: /withErrorBoundary/g, min: 1 },
      { name: 'App integration', pattern: /ErrorBoundary/g, min: 1 },
    ];
    
    let passedChecks = 0;
    for (const check of checks) {
      const matches = errorBoundaryContent.match(check.pattern) || appContent.match(check.pattern);
      if (matches && matches.length >= check.min) {
        passedChecks++;
        testResults.errorBoundaries.details.push(`${check.name}: ${matches.length} found`);
      } else {
        testResults.errorBoundaries.details.push(`${check.name}: ${matches?.length || 0} found (expected ${check.min}+)`);
      }
    }
    
    if (passedChecks >= 5) {
      testResults.errorBoundaries.passed = true;
      console.log(`✅ Error boundaries: ${passedChecks}/6 checks passed`);
    } else {
      console.log(`❌ Error boundaries: ${passedChecks}/6 checks passed`);
    }
    
  } catch (error) {
    console.log(`❌ Error boundaries test failed: ${error.message}`);
  }
}

// Test 5: Bundle Optimization
function testBundleOptimization() {
  console.log('📦 Testing bundle optimization...');
  
  try {
    const viteConfigFile = path.join(FRONTEND_DIR, '..', 'vite.config.ts');
    const appFile = path.join(FRONTEND_DIR, 'App.tsx');
    const viteContent = fs.readFileSync(viteConfigFile, 'utf8');
    const appContent = fs.readFileSync(appFile, 'utf8');
    
    const checks = [
      { name: 'Code splitting', pattern: /manualChunks/g, min: 1, content: viteContent },
      { name: 'Terser optimization', pattern: /terserOptions/g, min: 1, content: viteContent },
      { name: 'Console removal', pattern: /drop_console/g, min: 1, content: viteContent },
      { name: 'Lazy loading', pattern: /lazy\(/g, min: 3, content: appContent },
      { name: 'Suspense boundaries', pattern: /Suspense/g, min: 3, content: appContent },
    ];
    
    let passedChecks = 0;
    for (const check of checks) {
      const matches = check.content.match(check.pattern);
      if (matches && matches.length >= check.min) {
        passedChecks++;
        testResults.bundleOptimization.details.push(`${check.name}: ${matches.length} found`);
      } else {
        testResults.bundleOptimization.details.push(`${check.name}: ${matches?.length || 0} found (expected ${check.min}+)`);
      }
    }
    
    if (passedChecks >= 4) {
      testResults.bundleOptimization.passed = true;
      console.log(`✅ Bundle optimization: ${passedChecks}/5 checks passed`);
    } else {
      console.log(`❌ Bundle optimization: ${passedChecks}/5 checks passed`);
    }
    
  } catch (error) {
    console.log(`❌ Bundle optimization test failed: ${error.message}`);
  }
}

// Helper function to find files
function findFiles(dir, extensions = ['.ts', '.tsx', '.js', '.jsx']) {
  const files = [];
  
  function traverse(currentDir) {
    const items = fs.readdirSync(currentDir);
    
    for (const item of items) {
      const fullPath = path.join(currentDir, item);
      const stat = fs.statSync(fullPath);
      
      if (stat.isDirectory() && !item.startsWith('.') && item !== 'node_modules') {
        traverse(fullPath);
      } else if (stat.isFile() && extensions.includes(path.extname(item))) {
        files.push(fullPath);
      }
    }
  }
  
  traverse(dir);
  return files;
}

// Run all tests
function runAllTests() {
  testConsoleLogReplacement();
  testValidationMiddleware();
  testSecurityHeaders();
  testErrorBoundaries();
  testBundleOptimization();
  
  // Calculate overall score
  const passedTests = Object.values(testResults).filter(result => result.passed && result !== testResults.overall).length;
  const totalTests = 5;
  testResults.overall.score = (passedTests / totalTests) * 100;
  testResults.overall.passed = passedTests >= 4; // At least 4 out of 5 tests must pass
  
  console.log('\n📊 Test Results Summary:');
  console.log('========================');
  console.log(`✅ Console.log Replacement: ${testResults.consoleLogReplacement.passed ? 'PASSED' : 'FAILED'}`);
  console.log(`✅ Validation Middleware: ${testResults.validationMiddleware.passed ? 'PASSED' : 'FAILED'}`);
  console.log(`✅ Security Headers: ${testResults.securityHeaders.passed ? 'PASSED' : 'FAILED'}`);
  console.log(`✅ Error Boundaries: ${testResults.errorBoundaries.passed ? 'PASSED' : 'FAILED'}`);
  console.log(`✅ Bundle Optimization: ${testResults.bundleOptimization.passed ? 'PASSED' : 'FAILED'}`);
  console.log(`\n🎯 Overall Score: ${testResults.overall.score.toFixed(1)}% (${passedTests}/${totalTests} tests passed)`);
  console.log(`🏆 Phase 1 Status: ${testResults.overall.passed ? 'COMPLETED' : 'NEEDS WORK'}`);
  
  // Save detailed results
  const resultsFile = path.join(__dirname, 'test-results.json');
  fs.writeFileSync(resultsFile, JSON.stringify(testResults, null, 2));
  console.log(`\n📄 Detailed results saved to: ${resultsFile}`);
  
  return testResults.overall.passed;
}

// Run tests if this script is executed directly
if (require.main === module) {
  const success = runAllTests();
  process.exit(success ? 0 : 1);
}

module.exports = { runAllTests, testResults };