rpa_vision_v3/visual_workflow_builder/test_compilation_fix.py

#!/usr/bin/env python3
"""
Test de Correction de Compilation TypeScript
Auteur : Dom, Alice, Kiro - 7 janvier 2026

Vérifie que les corrections TypeScript ont résolu les problèmes de compilation
"""

import subprocess
import sys
import os
import json
from pathlib import Path

def run_command(cmd, cwd=None):
    """Exécute une commande et retourne le résultat"""
    try:
        result = subprocess.run(
            cmd, 
            shell=True, 
            cwd=cwd,
            capture_output=True, 
            text=True,
            timeout=60
        )
        return result.returncode == 0, result.stdout, result.stderr
    except subprocess.TimeoutExpired:
        return False, "", "Timeout"

def test_typescript_compilation():
    """Test la compilation TypeScript avec validation des artefacts"""
    print("🔧 Test de Compilation TypeScript...")
    
    frontend_dir = Path(__file__).parent / "frontend"
    
    # Vérifier que le répertoire existe
    if not frontend_dir.exists():
        print("❌ Répertoire frontend non trouvé")
        return False
    
    # Vérifier que package.json existe et contient les scripts nécessaires
    package_json = frontend_dir / "package.json"
    if not package_json.exists():
        print("❌ package.json non trouvé")
        return False
    
    try:
        with open(package_json, 'r', encoding='utf-8') as f:
            package_data = json.load(f)
        
        if "build" not in package_data.get("scripts", {}):
            print("❌ Script 'build' non trouvé dans package.json")
            return False
            
    except json.JSONDecodeError:
        print("❌ package.json invalide")
        return False
    
    # Nettoyer le répertoire de build précédent
    dist_dir = frontend_dir / "dist"
    if dist_dir.exists():
        import shutil
        shutil.rmtree(dist_dir)
    
    # Test de compilation
    success, stdout, stderr = run_command("npm run build", cwd=frontend_dir)
    
    if success:
        print("✅ Compilation TypeScript réussie")
        
        # Vérifier que les artefacts de build ont été créés
        if dist_dir.exists():
            build_files = list(dist_dir.glob("**/*"))
            if build_files:
                print(f"✅ {len(build_files)} fichiers générés dans dist/")
                
                # Vérifier la présence de fichiers essentiels
                js_files = list(dist_dir.glob("**/*.js"))
                css_files = list(dist_dir.glob("**/*.css"))
                
                if js_files:
                    print(f"✅ {len(js_files)} fichiers JavaScript générés")
                if css_files:
                    print(f"✅ {len(css_files)} fichiers CSS générés")
                    
                return True
            else:
                print("⚠️ Compilation réussie mais aucun fichier généré")
                return False
        else:
            print("⚠️ Compilation réussie mais répertoire dist/ non créé")
            return False
    else:
        print("❌ Erreurs de compilation TypeScript:")
        print(stderr)
        return False

def test_type_checking():
    """Test le type checking TypeScript"""
    print("🔍 Test de Vérification des Types...")
    
    frontend_dir = Path(__file__).parent / "frontend"
    
    # Test de type checking
    success, stdout, stderr = run_command("npx tsc --noEmit", cwd=frontend_dir)
    
    if success:
        print("✅ Vérification des types réussie")
        return True
    else:
        print("❌ Erreurs de types:")
        print(stderr)
        return False

def check_fixed_files():
    """Vérifie que les fichiers corrigés existent et sont valides"""
    print("📁 Vérification des Fichiers Corrigés...")
    
    files_to_check = [
        "frontend/src/components/LanguageSelector/index.tsx",
        "frontend/src/components/RealDemoTab/index.tsx", 
        "frontend/src/components/RealDemo/index.tsx",
        "frontend/src/services/LocalizationService.ts"
    ]
    
    base_dir = Path(__file__).parent
    all_exist = True
    
    for file_path in files_to_check:
        full_path = base_dir / file_path
        if full_path.exists():
            print(f"✅ {file_path} existe")
        else:
            print(f"❌ {file_path} manquant")
            all_exist = False
    
    return all_exist

def test_localization_files():
    """Vérifie que les fichiers de localisation sont présents"""
    print("🌍 Vérification des Fichiers de Localisation...")
    
    i18n_dir = Path(__file__).parent.parent / "i18n"
    
    required_files = [
        "config.json",
        "fr.json", 
        "en.json",
        "es.json",
        "de.json"
    ]
    
    all_exist = True
    
    for file_name in required_files:
        file_path = i18n_dir / file_name
        if file_path.exists():
            print(f"✅ {file_name} existe")
            
            # Vérifier que c'est du JSON valide
            try:
                with open(file_path, 'r', encoding='utf-8') as f:
                    json.load(f)
                print(f"✅ {file_name} est un JSON valide")
            except json.JSONDecodeError as e:
                print(f"❌ {file_name} contient du JSON invalide: {e}")
                all_exist = False
        else:
            print(f"❌ {file_name} manquant")
            all_exist = False
    
    return all_exist

def main():
    """Fonction principale de test"""
    print("🚀 Test de Correction des Erreurs TypeScript")
    print("=" * 50)
    
    tests = [
        ("Fichiers Corrigés", check_fixed_files),
        ("Fichiers de Localisation", test_localization_files),
        ("Compilation TypeScript", test_typescript_compilation),
        ("Vérification des Types", test_type_checking)
    ]
    
    results = []
    
    for test_name, test_func in tests:
        print(f"\n📋 {test_name}")
        print("-" * 30)
        
        try:
            result = test_func()
            results.append((test_name, result))
        except Exception as e:
            print(f"❌ Erreur lors du test {test_name}: {e}")
            results.append((test_name, False))
    
    # Résumé
    print("\n" + "=" * 50)
    print("📊 RÉSUMÉ DES TESTS")
    print("=" * 50)
    
    passed = 0
    total = len(results)
    
    for test_name, result in results:
        status = "✅ RÉUSSI" if result else "❌ ÉCHOUÉ"
        print(f"{test_name}: {status}")
        if result:
            passed += 1
    
    print(f"\nRésultat: {passed}/{total} tests réussis")
    
    if passed == total:
        print("\n🎉 Toutes les corrections TypeScript sont fonctionnelles!")
        print("\n📝 Résumé des corrections appliquées:")
        print("• Correction du type 'size' pour le composant Chip Material-UI")
        print("• Suppression de l'import VisibilityIcon non utilisé")
        print("• Correction de la variable 'event' non utilisée")
        print("• Ajout de l'import React manquant dans LocalizationService")
        print("• Création du composant RealDemo manquant")
        
        print("\n🔧 Le Visual Workflow Builder peut maintenant être compilé sans erreurs!")
        return True
    else:
        print(f"\n⚠️  {total - passed} test(s) ont échoué. Vérifiez les erreurs ci-dessus.")
        return False

if __name__ == "__main__":
    success = main()
    sys.exit(0 if success else 1)