seo-generator-server/tests/integration/run-integration-tests.js

#!/usr/bin/env node
// ========================================
// RUNNER TESTS D'INTÉGRATION
// Description: Lance les vrais tests qui valident le comportement système
// ========================================

const { spawn } = require('child_process');
const path = require('path');

console.log(`
╔════════════════════════════════════════════════════════════╗
║                 🔥 TESTS D'INTÉGRATION RÉELS                ║
║              Validation comportement système                ║
╚════════════════════════════════════════════════════════════╝
`);

async function runIntegrationTests() {
  const testFiles = [
    'real-workflow.test.js',
    'api-consistency.test.js'
  ];

  let totalTests = 0;
  let passedTests = 0;
  let failedTests = 0;

  for (const testFile of testFiles) {
    console.log(`\n🧪 === EXÉCUTION: ${testFile} ===`);

    try {
      const result = await runSingleTest(testFile);

      if (result.success) {
        console.log(`✅ ${testFile}: RÉUSSI`);
        passedTests += result.passed;
        totalTests += result.total;
      } else {
        console.log(`❌ ${testFile}: ÉCHEC`);
        failedTests += result.failed;
        totalTests += result.total;

        if (result.error) {
          console.error(`💥 Erreur: ${result.error}`);
        }
      }

    } catch (error) {
      console.error(`💥 Erreur fatale lors du test ${testFile}: ${error.message}`);
      failedTests++;
      totalTests++;
    }
  }

  // Résumé final
  console.log(`
╔════════════════════════════════════════════════════════════╗
║                     📊 RÉSUMÉ FINAL                        ║
╠════════════════════════════════════════════════════════════╣
║  Total tests:    ${totalTests.toString().padStart(3)} tests                              ║
║  Réussis:        ${passedTests.toString().padStart(3)} tests (${passedTests > 0 ? '✅' : '❌'})                           ║
║  Échoués:        ${failedTests.toString().padStart(3)} tests (${failedTests === 0 ? '✅' : '❌'})                           ║
║                                                            ║
║  Status global:  ${failedTests === 0 ? '🎯 TOUS LES TESTS RÉUSSIS' : '💥 DES TESTS ONT ÉCHOUÉ'}               ║
╚════════════════════════════════════════════════════════════╝
  `);

  if (failedTests > 0) {
    console.log(`
🚨 ACTION REQUISE:
   ${failedTests} test(s) ont échoué. Le système n'est pas prêt pour la production.
   Vérifie les erreurs ci-dessus et corrige les problèmes identifiés.
    `);
    process.exit(1);
  } else {
    console.log(`
🎉 SYSTÈME VALIDÉ:
   Tous les tests d'intégration sont passés.
   Le système est cohérent et prêt pour la production !
    `);
    process.exit(0);
  }
}

function runSingleTest(testFile) {
  return new Promise((resolve) => {
    const testPath = path.join(__dirname, testFile);

    console.log(`📡 Lancement: node --test ${testPath}`);

    const child = spawn('node', ['--test', testPath], {
      stdio: ['pipe', 'pipe', 'pipe'],
      cwd: path.join(__dirname, '../..')
    });

    let stdout = '';
    let stderr = '';

    child.stdout.on('data', (data) => {
      const output = data.toString();
      stdout += output;
      // Afficher en temps réel pour feedback
      process.stdout.write(output);
    });

    child.stderr.on('data', (data) => {
      const output = data.toString();
      stderr += output;
      // Afficher erreurs en temps réel
      process.stderr.write(output);
    });

    child.on('close', (code) => {
      const success = code === 0;

      // Parser les résultats du test runner Node.js
      const testResults = parseTestOutput(stdout);

      resolve({
        success,
        total: testResults.total,
        passed: testResults.passed,
        failed: testResults.failed,
        error: success ? null : (stderr || 'Test failed with code ' + code)
      });
    });

    child.on('error', (error) => {
      resolve({
        success: false,
        total: 1,
        passed: 0,
        failed: 1,
        error: error.message
      });
    });
  });
}

function parseTestOutput(output) {
  // Parser basique pour extraire les résultats du test runner Node.js
  const lines = output.split('\n');

  let total = 0;
  let passed = 0;
  let failed = 0;

  for (const line of lines) {
    // Chercher patterns comme "✓ test name" ou "✗ test name"
    if (line.includes('✓') || line.includes('ok ')) {
      passed++;
      total++;
    } else if (line.includes('✗') || line.includes('not ok ')) {
      failed++;
      total++;
    }

    // Parser summary si disponible
    const summaryMatch = line.match(/tests (\d+), pass (\d+), fail (\d+)/);
    if (summaryMatch) {
      total = parseInt(summaryMatch[1]);
      passed = parseInt(summaryMatch[2]);
      failed = parseInt(summaryMatch[3]);
      break;
    }
  }

  return { total, passed, failed };
}

// Configuration environnement pour les tests
process.env.NODE_ENV = 'test';
process.env.LOG_LEVEL = 'INFO'; // Réduire verbosité pendant tests

// Démarrer les tests
runIntegrationTests().catch((error) => {
  console.error(`💥 Erreur fatale du runner: ${error.message}`);
  process.exit(1);
});