LeDiscord/frontend/test-env.js

#!/usr/bin/env node

/**
 * Script de test des environnements Frontend LeDiscord
 * Vérifie la cohérence des configurations et évite les problèmes de mixed content
 */

const fs = require('fs')
const path = require('path')

// Couleurs pour la console
const colors = {
  reset: '\x1b[0m',
  bright: '\x1b[1m',
  red: '\x1b[31m',
  green: '\x1b[32m',
  yellow: '\x1b[33m',
  blue: '\x1b[34m',
  magenta: '\x1b[35m',
  cyan: '\x1b[36m'
}

function log(message, color = 'reset') {
  console.log(`${colors[color]}${message}${colors.reset}`)
}

function testEnvironment(envName) {
  log(`\n🔍 Test de l'environnement: ${envName.toUpperCase()}`, 'cyan')
  
  const envFile = path.join(__dirname, `env.${envName}`)
  
  if (!fs.existsSync(envFile)) {
    log(`❌ Fichier ${envFile} non trouvé`, 'red')
    return false
  }
  
  log(`✅ Fichier ${envFile} trouvé`, 'green')
  
  // Lire le fichier d'environnement
  const envContent = fs.readFileSync(envFile, 'utf8')
  const envVars = {}
  
  // Parser les variables d'environnement
  envContent.split('\n').forEach(line => {
    line = line.trim()
    if (line && !line.startsWith('#')) {
      const [key, ...valueParts] = line.split('=')
      if (key && valueParts.length > 0) {
        envVars[key] = valueParts.join('=')
      }
    }
  })
  
  // Vérifier les variables requises
  const requiredVars = ['VITE_API_URL', 'VITE_APP_URL', 'VITE_UPLOAD_URL', 'VITE_ENVIRONMENT']
  let allValid = true
  
  requiredVars.forEach(varName => {
    if (!envVars[varName]) {
      log(`❌ Variable manquante: ${varName}`, 'red')
      allValid = false
    } else {
      log(`✅ ${varName}: ${envVars[varName]}`, 'green')
    }
  })
  
  // Vérifier la cohérence des protocoles
  if (envVars.VITE_API_URL && envVars.VITE_APP_URL) {
    const apiProtocol = envVars.VITE_API_URL.split('://')[0]
    const appProtocol = envVars.VITE_APP_URL.split('://')[0]
    
    if (apiProtocol !== appProtocol) {
      log(`⚠️  Protocoles différents: API=${apiProtocol}, APP=${appProtocol}`, 'yellow')
      log(`   Cela peut causer des problèmes de mixed content!`, 'yellow')
      allValid = false
    } else {
      log(`✅ Protocoles cohérents: ${apiProtocol}`, 'green')
    }
  }
  
  // Vérifier la cohérence des domaines
  if (envVars.VITE_API_URL && envVars.VITE_APP_URL) {
    const apiDomain = envVars.VITE_API_URL.split('://')[1]?.split('/')[0]
    const appDomain = envVars.VITE_APP_URL.split('://')[1]?.split('/')[0]
    
    if (apiDomain && appDomain) {
      if (envName === 'local') {
        // En local, les domaines peuvent être différents (localhost:8000 vs localhost:5173)
        log(`✅ Domaines locaux: API=${apiDomain}, APP=${appDomain}`, 'green')
      } else if (apiDomain.includes('dev.') && appDomain.includes('dev.')) {
        log(`✅ Domaines de développement cohérents: ${apiDomain}`, 'green')
      } else if (!apiDomain.includes('dev.') && !appDomain.includes('dev.')) {
        log(`✅ Domaines de production cohérents: ${apiDomain}`, 'green')
      } else {
        log(`⚠️  Domaines incohérents: API=${apiDomain}, APP=${appDomain}`, 'yellow')
        allValid = false
      }
    }
  }
  
  // Vérifier l'environnement spécifié
  if (envVars.VITE_ENVIRONMENT && envVars.VITE_ENVIRONMENT !== envName) {
    log(`⚠️  Environnement spécifié (${envVars.VITE_ENVIRONMENT}) ne correspond pas au nom du fichier (${envName})`, 'yellow')
    allValid = false
  }
  
  return allValid
}

function testDockerfiles() {
  log(`\n🐳 Test des Dockerfiles`, 'cyan')
  
  const dockerfiles = ['Dockerfile.local', 'Dockerfile.dev', 'Dockerfile.prod']
  let allValid = true
  
  dockerfiles.forEach(dockerfile => {
    const dockerfilePath = path.join(__dirname, dockerfile)
    if (fs.existsSync(dockerfilePath)) {
      log(`✅ ${dockerfile} trouvé`, 'green')
      
      // Vérifier que le Dockerfile copie le bon fichier d'environnement
      const content = fs.readFileSync(dockerfilePath, 'utf8')
      const envName = dockerfile.replace('Dockerfile.', '')
      
      if (content.includes(`env.${envName}`)) {
        log(`✅ ${dockerfile} copie le bon fichier env.${envName}`, 'green')
      } else {
        log(`❌ ${dockerfile} ne copie pas env.${envName}`, 'red')
        allValid = false
      }
    } else {
      log(`❌ ${dockerfile} manquant`, 'red')
      allValid = false
    }
  })
  
  return allValid
}

function testViteConfig() {
  log(`\n⚙️  Test de la configuration Vite`, 'cyan')
  
  const viteConfigPath = path.join(__dirname, 'vite.config.js')
  
  if (!fs.existsSync(viteConfigPath)) {
    log(`❌ vite.config.js non trouvé`, 'red')
    return false
  }
  
  log(`✅ vite.config.js trouvé`, 'green')
  
  // Vérifier que la configuration gère les environnements
  const content = fs.readFileSync(viteConfigPath, 'utf8')
  
  if (content.includes('getEnvironmentConfig')) {
    log(`✅ Configuration par environnement détectée`, 'green')
  } else {
    log(`⚠️  Configuration par environnement non détectée`, 'yellow')
  }
  
  if (content.includes('proxy')) {
    log(`✅ Configuration proxy détectée`, 'green')
  } else {
    log(`⚠️  Configuration proxy non détectée`, 'yellow')
  }
  
  return true
}

function main() {
  const args = process.argv.slice(2)
  
  log(`🚀 Test des environnements Frontend LeDiscord`, 'bright')
  log(`📁 Répertoire: ${__dirname}`, 'blue')
  
  let allTestsPassed = true
  
  if (args.length > 0) {
    // Test d'un environnement spécifique
    const envName = args[0]
    if (['local', 'development', 'production'].includes(envName)) {
      allTestsPassed = testEnvironment(envName) && allTestsPassed
    } else {
      log(`❌ Environnement invalide: ${envName}`, 'red')
      log(`   Environnements valides: local, development, production`, 'yellow')
      process.exit(1)
    }
  } else {
    // Test de tous les environnements
    log(`\n🌍 Test de tous les environnements`, 'cyan')
    
    const environments = ['local', 'development', 'production']
    environments.forEach(env => {
      allTestsPassed = testEnvironment(env) && allTestsPassed
    })
  }
  
  // Tests généraux
  allTestsPassed = testDockerfiles() && allTestsPassed
  allTestsPassed = testViteConfig() && allTestsPassed
  
  // Résumé
  log(`\n📊 Résumé des tests`, 'cyan')
  if (allTestsPassed) {
    log(`✅ Tous les tests sont passés avec succès!`, 'green')
    log(`🎉 Votre configuration frontend est prête pour la production!`, 'green')
  } else {
    log(`❌ Certains tests ont échoué`, 'red')
    log(`🔧 Veuillez corriger les problèmes avant de continuer`, 'yellow')
    process.exit(1)
  }
  
  log(`\n💡 Conseils pour éviter les problèmes de mixed content:`, 'cyan')
  log(`   - Assurez-vous que toutes les URLs d'un même environnement utilisent le même protocole`, 'blue')
  log(`   - En local: utilisez HTTP (http://localhost:*)`, 'blue')
  log(`   - En développement/production: utilisez HTTPS (https://*.lediscord.com)`, 'blue')
  log(`   - Vérifiez que VITE_API_URL et VITE_APP_URL sont cohérents`, 'blue')
}

if (require.main === module) {
  main()
}