a27b74cf22
- Frontend v4 accessible sur réseau local (192.168.1.40) - Ports ouverts: 3002 (frontend), 5001 (backend), 5004 (dashboard) - Ollama GPU fonctionnel - Self-healing interactif - Dashboard confiance Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
360 lines
13 KiB
Python
360 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Test Frontend Propriétés VWB - Validation de l'affichage dans l'interface
|
|
Auteur : Dom, Alice, Kiro - 10 janvier 2026
|
|
|
|
Ce script démarre le frontend avec le composant de test et valide
|
|
l'affichage des propriétés d'étapes VWB.
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import json
|
|
import time
|
|
import requests
|
|
import subprocess
|
|
import webbrowser
|
|
from pathlib import Path
|
|
from typing import Dict, List, Any, Optional
|
|
|
|
# Configuration
|
|
VWB_BACKEND_URL = "http://localhost:5004"
|
|
VWB_FRONTEND_URL = "http://localhost:3000"
|
|
TEST_COMPONENT_URL = f"{VWB_FRONTEND_URL}/test-properties"
|
|
|
|
class VWBFrontendTesteur:
|
|
"""Testeur pour l'interface frontend VWB"""
|
|
|
|
def __init__(self):
|
|
self.backend_url = VWB_BACKEND_URL
|
|
self.frontend_url = VWB_FRONTEND_URL
|
|
self.backend_process = None
|
|
self.frontend_process = None
|
|
|
|
def verifier_backend(self) -> bool:
|
|
"""Vérifier que le backend est disponible"""
|
|
print("🔍 Vérification du backend...")
|
|
|
|
try:
|
|
response = requests.get(f"{self.backend_url}/health", timeout=5)
|
|
if response.status_code == 200:
|
|
health_data = response.json()
|
|
actions_count = health_data.get('services', {}).get('actions', 0)
|
|
print(f"✅ Backend disponible - {actions_count} actions")
|
|
return True
|
|
else:
|
|
print(f"❌ Backend répond avec code {response.status_code}")
|
|
return False
|
|
except Exception as e:
|
|
print(f"❌ Backend non accessible: {e}")
|
|
return False
|
|
|
|
def demarrer_backend(self) -> bool:
|
|
"""Démarrer le backend si nécessaire"""
|
|
if self.verifier_backend():
|
|
return True
|
|
|
|
print("🚀 Démarrage du backend VWB...")
|
|
|
|
try:
|
|
# Changer vers le répertoire VWB
|
|
vwb_dir = Path("visual_workflow_builder")
|
|
if not vwb_dir.exists():
|
|
print("❌ Répertoire visual_workflow_builder non trouvé")
|
|
return False
|
|
|
|
# Démarrer le backend
|
|
backend_script = vwb_dir / "backend" / "app_catalogue_simple.py"
|
|
if not backend_script.exists():
|
|
print("❌ Script backend non trouvé")
|
|
return False
|
|
|
|
# Commande pour démarrer le backend
|
|
cmd = [
|
|
sys.executable, "-m", "backend.app_catalogue_simple"
|
|
]
|
|
|
|
print(f"Commande: {' '.join(cmd)}")
|
|
print(f"Répertoire: {vwb_dir.absolute()}")
|
|
|
|
# Démarrer en arrière-plan
|
|
self.backend_process = subprocess.Popen(
|
|
cmd,
|
|
cwd=vwb_dir,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
text=True
|
|
)
|
|
|
|
# Attendre que le backend démarre
|
|
print("⏳ Attente du démarrage du backend...")
|
|
for i in range(30): # 30 secondes max
|
|
time.sleep(1)
|
|
if self.verifier_backend():
|
|
print("✅ Backend démarré avec succès")
|
|
return True
|
|
print(f" Tentative {i+1}/30...")
|
|
|
|
print("❌ Timeout démarrage backend")
|
|
return False
|
|
|
|
except Exception as e:
|
|
print(f"❌ Erreur démarrage backend: {e}")
|
|
return False
|
|
|
|
def modifier_app_pour_test(self) -> bool:
|
|
"""Modifier App.tsx pour inclure le composant de test"""
|
|
print("🔧 Modification de App.tsx pour inclure le test...")
|
|
|
|
app_file = Path("visual_workflow_builder/frontend/src/App.tsx")
|
|
if not app_file.exists():
|
|
print("❌ Fichier App.tsx non trouvé")
|
|
return False
|
|
|
|
try:
|
|
# Lire le contenu actuel
|
|
with open(app_file, 'r', encoding='utf-8') as f:
|
|
content = f.read()
|
|
|
|
# Vérifier si le test est déjà ajouté
|
|
if 'TestPropertiesPanel' in content:
|
|
print("✅ Composant de test déjà intégré")
|
|
return True
|
|
|
|
# Ajouter l'import du composant de test
|
|
import_line = "import TestPropertiesPanel from './components/TestPropertiesPanel';"
|
|
|
|
# Trouver la ligne d'import React
|
|
lines = content.split('\n')
|
|
import_index = -1
|
|
for i, line in enumerate(lines):
|
|
if line.startswith('import React') or line.startswith('import {'):
|
|
import_index = i
|
|
break
|
|
|
|
if import_index >= 0:
|
|
lines.insert(import_index + 1, import_line)
|
|
else:
|
|
lines.insert(0, import_line)
|
|
|
|
# Ajouter la route de test
|
|
route_addition = '''
|
|
{/* Route de test pour les propriétés VWB */}
|
|
<Route path="/test-properties" element={<TestPropertiesPanel />} />'''
|
|
|
|
# Trouver où insérer la route
|
|
route_inserted = False
|
|
for i, line in enumerate(lines):
|
|
if '<Routes>' in line and not route_inserted:
|
|
lines.insert(i + 1, route_addition)
|
|
route_inserted = True
|
|
break
|
|
|
|
# Sauvegarder le fichier modifié
|
|
modified_content = '\n'.join(lines)
|
|
with open(app_file, 'w', encoding='utf-8') as f:
|
|
f.write(modified_content)
|
|
|
|
print("✅ App.tsx modifié avec succès")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"❌ Erreur modification App.tsx: {e}")
|
|
return False
|
|
|
|
def demarrer_frontend(self) -> bool:
|
|
"""Démarrer le frontend"""
|
|
print("🚀 Démarrage du frontend VWB...")
|
|
|
|
try:
|
|
frontend_dir = Path("visual_workflow_builder/frontend")
|
|
if not frontend_dir.exists():
|
|
print("❌ Répertoire frontend non trouvé")
|
|
return False
|
|
|
|
# Vérifier que node_modules existe
|
|
node_modules = frontend_dir / "node_modules"
|
|
if not node_modules.exists():
|
|
print("⏳ Installation des dépendances npm...")
|
|
subprocess.run(["npm", "install"], cwd=frontend_dir, check=True)
|
|
|
|
# Démarrer le serveur de développement
|
|
print("⏳ Démarrage du serveur de développement...")
|
|
|
|
env = os.environ.copy()
|
|
env['BROWSER'] = 'none' # Empêcher l'ouverture automatique du navigateur
|
|
|
|
self.frontend_process = subprocess.Popen(
|
|
["npm", "start"],
|
|
cwd=frontend_dir,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
text=True,
|
|
env=env
|
|
)
|
|
|
|
# Attendre que le frontend démarre
|
|
print("⏳ Attente du démarrage du frontend...")
|
|
for i in range(60): # 60 secondes max
|
|
time.sleep(1)
|
|
try:
|
|
response = requests.get(self.frontend_url, timeout=2)
|
|
if response.status_code == 200:
|
|
print("✅ Frontend démarré avec succès")
|
|
return True
|
|
except:
|
|
pass
|
|
print(f" Tentative {i+1}/60...")
|
|
|
|
print("❌ Timeout démarrage frontend")
|
|
return False
|
|
|
|
except Exception as e:
|
|
print(f"❌ Erreur démarrage frontend: {e}")
|
|
return False
|
|
|
|
def ouvrir_page_test(self):
|
|
"""Ouvrir la page de test dans le navigateur"""
|
|
print("🌐 Ouverture de la page de test...")
|
|
|
|
test_url = f"{self.frontend_url}/test-properties"
|
|
|
|
try:
|
|
webbrowser.open(test_url)
|
|
print(f"✅ Page de test ouverte: {test_url}")
|
|
except Exception as e:
|
|
print(f"⚠️ Impossible d'ouvrir automatiquement le navigateur: {e}")
|
|
print(f" Ouvrez manuellement: {test_url}")
|
|
|
|
def afficher_instructions(self):
|
|
"""Afficher les instructions pour l'utilisateur"""
|
|
print("\n" + "="*60)
|
|
print("🎯 INSTRUCTIONS POUR TESTER LES PROPRIÉTÉS VWB")
|
|
print("="*60)
|
|
|
|
print(f"\n1. 🌐 OUVRIR LA PAGE DE TEST")
|
|
print(f" URL: {self.frontend_url}/test-properties")
|
|
print(f" La page devrait s'ouvrir automatiquement dans votre navigateur")
|
|
|
|
print(f"\n2. 🧪 EXÉCUTER LES TESTS")
|
|
print(f" - Cliquez sur 'Exécuter les Tests'")
|
|
print(f" - Vérifiez que tous les tests sont verts ✅")
|
|
print(f" - Si des tests échouent ❌, vérifiez la console du navigateur")
|
|
|
|
print(f"\n3. 👀 VÉRIFIER L'AFFICHAGE")
|
|
print(f" - L'aperçu du Properties Panel doit s'afficher")
|
|
print(f" - Les propriétés de l'action VWB doivent être visibles")
|
|
print(f" - Les paramètres requis et optionnels doivent être listés")
|
|
|
|
print(f"\n4. 🎨 TESTER L'INTERACTION")
|
|
print(f" - Changez l'action à tester avec les boutons")
|
|
print(f" - Vérifiez que les propriétés changent selon l'action")
|
|
print(f" - Testez la sélection d'ancres visuelles")
|
|
|
|
print(f"\n5. 🔧 DÉBOGUER SI NÉCESSAIRE")
|
|
print(f" - Ouvrez les outils de développement (F12)")
|
|
print(f" - Vérifiez la console pour les erreurs")
|
|
print(f" - Vérifiez l'onglet Network pour les requêtes API")
|
|
|
|
print(f"\n📊 URLS IMPORTANTES:")
|
|
print(f" - Backend API: {self.backend_url}")
|
|
print(f" - Frontend: {self.frontend_url}")
|
|
print(f" - Page de test: {self.frontend_url}/test-properties")
|
|
print(f" - API Catalogue: {self.backend_url}/api/vwb/catalog/actions")
|
|
|
|
print(f"\n⏹️ ARRÊTER LES SERVICES:")
|
|
print(f" - Appuyez sur Ctrl+C dans ce terminal")
|
|
print(f" - Ou fermez cette fenêtre de terminal")
|
|
|
|
print("\n" + "="*60)
|
|
|
|
def nettoyer(self):
|
|
"""Nettoyer les processus"""
|
|
print("\n🧹 Nettoyage des processus...")
|
|
|
|
if self.frontend_process:
|
|
try:
|
|
self.frontend_process.terminate()
|
|
self.frontend_process.wait(timeout=5)
|
|
print("✅ Frontend arrêté")
|
|
except:
|
|
try:
|
|
self.frontend_process.kill()
|
|
print("✅ Frontend forcé à s'arrêter")
|
|
except:
|
|
print("⚠️ Impossible d'arrêter le frontend")
|
|
|
|
if self.backend_process:
|
|
try:
|
|
self.backend_process.terminate()
|
|
self.backend_process.wait(timeout=5)
|
|
print("✅ Backend arrêté")
|
|
except:
|
|
try:
|
|
self.backend_process.kill()
|
|
print("✅ Backend forcé à s'arrêter")
|
|
except:
|
|
print("⚠️ Impossible d'arrêter le backend")
|
|
|
|
def executer_test_complet(self):
|
|
"""Exécuter le test complet"""
|
|
print("🚀 TEST FRONTEND PROPRIÉTÉS VWB")
|
|
print("=" * 50)
|
|
|
|
try:
|
|
# Étape 1: Vérifier/démarrer le backend
|
|
if not self.demarrer_backend():
|
|
print("❌ Impossible de démarrer le backend")
|
|
return False
|
|
|
|
# Étape 2: Modifier App.tsx pour inclure le test
|
|
if not self.modifier_app_pour_test():
|
|
print("❌ Impossible de modifier App.tsx")
|
|
return False
|
|
|
|
# Étape 3: Démarrer le frontend
|
|
if not self.demarrer_frontend():
|
|
print("❌ Impossible de démarrer le frontend")
|
|
return False
|
|
|
|
# Étape 4: Ouvrir la page de test
|
|
self.ouvrir_page_test()
|
|
|
|
# Étape 5: Afficher les instructions
|
|
self.afficher_instructions()
|
|
|
|
# Étape 6: Attendre l'arrêt manuel
|
|
try:
|
|
print("\n⏳ Services en cours d'exécution... Appuyez sur Ctrl+C pour arrêter")
|
|
while True:
|
|
time.sleep(1)
|
|
except KeyboardInterrupt:
|
|
print("\n🛑 Arrêt demandé par l'utilisateur")
|
|
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"❌ Erreur: {e}")
|
|
return False
|
|
finally:
|
|
self.nettoyer()
|
|
|
|
def main():
|
|
"""Fonction principale"""
|
|
print("Test Frontend Propriétés VWB - 10 janvier 2026")
|
|
print("Auteur : Dom, Alice, Kiro")
|
|
print()
|
|
|
|
# Vérifier qu'on est dans le bon répertoire
|
|
if not os.path.exists('visual_workflow_builder'):
|
|
print("❌ Erreur: Exécuter depuis la racine du projet RPA Vision V3")
|
|
sys.exit(1)
|
|
|
|
# Créer et exécuter le testeur
|
|
testeur = VWBFrontendTesteur()
|
|
succes = testeur.executer_test_complet()
|
|
|
|
sys.exit(0 if succes else 1)
|
|
|
|
if __name__ == "__main__":
|
|
main() |