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>
310 lines
13 KiB
Python
310 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Test des Propriétés d'Étapes VWB - Validation de l'affichage des propriétés
|
|
Auteur : Dom, Alice, Kiro - 10 janvier 2026
|
|
|
|
Ce script teste l'affichage des propriétés des étapes VWB dans le Properties Panel
|
|
et identifie les problèmes d'intégration.
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import json
|
|
import time
|
|
import requests
|
|
import subprocess
|
|
from pathlib import Path
|
|
from typing import Dict, List, Any, Optional
|
|
|
|
# Configuration
|
|
VWB_BACKEND_URL = "http://localhost:5004"
|
|
VWB_FRONTEND_URL = "http://localhost:3000"
|
|
TIMEOUT = 10
|
|
|
|
class VWBPropertiesTesteur:
|
|
"""Testeur pour les propriétés d'étapes VWB"""
|
|
|
|
def __init__(self):
|
|
self.backend_url = VWB_BACKEND_URL
|
|
self.frontend_url = VWB_FRONTEND_URL
|
|
self.resultats = {
|
|
'backend_disponible': False,
|
|
'actions_disponibles': [],
|
|
'frontend_disponible': False,
|
|
'composants_presents': {},
|
|
'integration_fonctionnelle': False,
|
|
'erreurs': []
|
|
}
|
|
|
|
def tester_backend_catalogue(self) -> bool:
|
|
"""Tester la disponibilité du backend catalogue"""
|
|
print("🔍 Test du backend catalogue...")
|
|
|
|
try:
|
|
# Test de santé
|
|
response = requests.get(f"{self.backend_url}/health", timeout=TIMEOUT)
|
|
if response.status_code == 200:
|
|
health_data = response.json()
|
|
print(f"✅ Backend disponible - {health_data.get('services', {}).get('actions', 0)} actions")
|
|
self.resultats['backend_disponible'] = True
|
|
|
|
# Test des actions
|
|
response = requests.get(f"{self.backend_url}/api/vwb/catalog/actions", timeout=TIMEOUT)
|
|
if response.status_code == 200:
|
|
actions_data = response.json()
|
|
actions = actions_data.get('actions', [])
|
|
self.resultats['actions_disponibles'] = actions
|
|
print(f"✅ {len(actions)} actions disponibles dans le catalogue")
|
|
|
|
# Afficher les actions disponibles
|
|
for action in actions[:3]: # Afficher les 3 premières
|
|
print(f" - {action.get('id', 'N/A')}: {action.get('name', 'N/A')}")
|
|
|
|
return True
|
|
else:
|
|
self.resultats['erreurs'].append(f"Erreur API catalogue: {response.status_code}")
|
|
return False
|
|
else:
|
|
self.resultats['erreurs'].append(f"Backend non disponible: {response.status_code}")
|
|
return False
|
|
|
|
except Exception as e:
|
|
self.resultats['erreurs'].append(f"Erreur backend: {str(e)}")
|
|
print(f"❌ Backend non accessible: {e}")
|
|
return False
|
|
|
|
def verifier_composants_frontend(self) -> bool:
|
|
"""Vérifier la présence des composants frontend"""
|
|
print("🔍 Vérification des composants frontend...")
|
|
|
|
composants_requis = {
|
|
'VWBActionProperties': 'visual_workflow_builder/frontend/src/components/PropertiesPanel/VWBActionProperties.tsx',
|
|
'PropertiesPanel': 'visual_workflow_builder/frontend/src/components/PropertiesPanel/index.tsx',
|
|
'useVWBStepIntegration': 'visual_workflow_builder/frontend/src/hooks/useVWBStepIntegration.ts',
|
|
'catalogService': 'visual_workflow_builder/frontend/src/services/catalogService.ts',
|
|
'catalog_types': 'visual_workflow_builder/frontend/src/types/catalog.ts'
|
|
}
|
|
|
|
tous_presents = True
|
|
|
|
for nom, chemin in composants_requis.items():
|
|
if os.path.exists(chemin):
|
|
print(f"✅ {nom} présent")
|
|
self.resultats['composants_presents'][nom] = True
|
|
|
|
# Vérifier le contenu pour des mots-clés importants
|
|
try:
|
|
with open(chemin, 'r', encoding='utf-8') as f:
|
|
contenu = f.read()
|
|
|
|
if nom == 'VWBActionProperties':
|
|
if 'VWBActionProperties' in contenu and 'VisualAnchorEditor' in contenu:
|
|
print(f" ✅ {nom} contient les composants requis")
|
|
else:
|
|
print(f" ⚠️ {nom} manque des composants requis")
|
|
self.resultats['erreurs'].append(f"{nom} incomplet")
|
|
|
|
elif nom == 'PropertiesPanel':
|
|
if 'isVWBCatalogAction' in contenu and 'VWBActionProperties' in contenu:
|
|
print(f" ✅ {nom} intègre les actions VWB")
|
|
else:
|
|
print(f" ⚠️ {nom} n'intègre pas les actions VWB")
|
|
self.resultats['erreurs'].append(f"{nom} n'intègre pas VWB")
|
|
|
|
elif nom == 'useVWBStepIntegration':
|
|
if 'useIsVWBStep' in contenu and 'useVWBActionId' in contenu:
|
|
print(f" ✅ {nom} contient les hooks requis")
|
|
else:
|
|
print(f" ⚠️ {nom} manque des hooks requis")
|
|
self.resultats['erreurs'].append(f"{nom} hooks manquants")
|
|
|
|
except Exception as e:
|
|
print(f" ⚠️ Erreur lecture {nom}: {e}")
|
|
self.resultats['erreurs'].append(f"Erreur lecture {nom}: {e}")
|
|
|
|
else:
|
|
print(f"❌ {nom} manquant: {chemin}")
|
|
self.resultats['composants_presents'][nom] = False
|
|
tous_presents = False
|
|
|
|
return tous_presents
|
|
|
|
def tester_integration_complete(self) -> bool:
|
|
"""Tester l'intégration complète des propriétés VWB"""
|
|
print("🔍 Test de l'intégration complète...")
|
|
|
|
# Vérifier que le frontend peut démarrer
|
|
try:
|
|
# Vérifier si le serveur de développement est déjà en cours
|
|
try:
|
|
response = requests.get(f"{self.frontend_url}", timeout=5)
|
|
if response.status_code == 200:
|
|
print("✅ Frontend VWB accessible")
|
|
self.resultats['frontend_disponible'] = True
|
|
else:
|
|
print(f"⚠️ Frontend répond avec code {response.status_code}")
|
|
except:
|
|
print("⚠️ Frontend non accessible (normal si pas démarré)")
|
|
|
|
except Exception as e:
|
|
print(f"⚠️ Erreur test frontend: {e}")
|
|
|
|
# Tester la logique d'intégration
|
|
return self.tester_logique_integration()
|
|
|
|
def tester_logique_integration(self) -> bool:
|
|
"""Tester la logique d'intégration VWB"""
|
|
print("🔍 Test de la logique d'intégration...")
|
|
|
|
# Simuler une étape VWB
|
|
etape_vwb_simulee = {
|
|
'id': 'test_step_123',
|
|
'type': 'click_anchor',
|
|
'name': 'Cliquer sur élément',
|
|
'data': {
|
|
'isVWBCatalogAction': True,
|
|
'vwbActionId': 'click_anchor',
|
|
'parameters': {
|
|
'anchor': None,
|
|
'click_type': 'left'
|
|
}
|
|
}
|
|
}
|
|
|
|
# Vérifier que l'étape serait détectée comme VWB
|
|
if etape_vwb_simulee['data'].get('isVWBCatalogAction'):
|
|
print("✅ Étape VWB correctement identifiée")
|
|
|
|
# Vérifier que l'action existe dans le catalogue
|
|
action_id = etape_vwb_simulee['data'].get('vwbActionId')
|
|
if action_id:
|
|
actions_disponibles = self.resultats.get('actions_disponibles', [])
|
|
action_trouvee = any(action.get('id') == action_id for action in actions_disponibles)
|
|
|
|
if action_trouvee:
|
|
print(f"✅ Action {action_id} trouvée dans le catalogue")
|
|
self.resultats['integration_fonctionnelle'] = True
|
|
return True
|
|
else:
|
|
print(f"❌ Action {action_id} non trouvée dans le catalogue")
|
|
self.resultats['erreurs'].append(f"Action {action_id} manquante")
|
|
return False
|
|
else:
|
|
print("❌ Pas d'ID d'action VWB")
|
|
self.resultats['erreurs'].append("ID d'action VWB manquant")
|
|
return False
|
|
else:
|
|
print("❌ Étape non identifiée comme VWB")
|
|
self.resultats['erreurs'].append("Détection VWB défaillante")
|
|
return False
|
|
|
|
def diagnostiquer_problemes(self):
|
|
"""Diagnostiquer les problèmes identifiés"""
|
|
print("\n🔧 DIAGNOSTIC DES PROBLÈMES")
|
|
print("=" * 50)
|
|
|
|
if not self.resultats['backend_disponible']:
|
|
print("❌ PROBLÈME CRITIQUE: Backend catalogue non disponible")
|
|
print(" Solutions:")
|
|
print(" 1. Démarrer le backend VWB: python scripts/start_vwb_backend_catalogue_complet_10jan2026.py")
|
|
print(" 2. Vérifier l'environnement virtuel: source venv_v3/bin/activate")
|
|
print(" 3. Vérifier les dépendances: pip install -r requirements.txt")
|
|
|
|
if not all(self.resultats['composants_presents'].values()):
|
|
print("❌ PROBLÈME: Composants frontend manquants")
|
|
composants_manquants = [nom for nom, present in self.resultats['composants_presents'].items() if not present]
|
|
print(f" Composants manquants: {', '.join(composants_manquants)}")
|
|
|
|
if not self.resultats['integration_fonctionnelle']:
|
|
print("❌ PROBLÈME: Intégration VWB non fonctionnelle")
|
|
print(" Causes possibles:")
|
|
print(" 1. Actions VWB non chargées dans le catalogue")
|
|
print(" 2. Hook d'intégration défaillant")
|
|
print(" 3. Types TypeScript incorrects")
|
|
|
|
if self.resultats['erreurs']:
|
|
print("❌ ERREURS DÉTECTÉES:")
|
|
for erreur in self.resultats['erreurs']:
|
|
print(f" - {erreur}")
|
|
|
|
def generer_solution(self):
|
|
"""Générer une solution pour les problèmes identifiés"""
|
|
print("\n🛠️ PLAN DE RÉSOLUTION")
|
|
print("=" * 50)
|
|
|
|
if not self.resultats['backend_disponible']:
|
|
print("1. DÉMARRER LE BACKEND CATALOGUE")
|
|
print(" cd visual_workflow_builder")
|
|
print(" source ../venv_v3/bin/activate")
|
|
print(" python -m backend.app_catalogue_simple")
|
|
print()
|
|
|
|
if not self.resultats['integration_fonctionnelle']:
|
|
print("2. VÉRIFIER L'INTÉGRATION FRONTEND")
|
|
print(" - Vérifier que les actions VWB sont bien chargées")
|
|
print(" - Tester la détection d'étapes VWB")
|
|
print(" - Valider l'affichage du Properties Panel")
|
|
print()
|
|
|
|
print("3. TESTER L'INTÉGRATION COMPLÈTE")
|
|
print(" - Démarrer le frontend: npm start (dans visual_workflow_builder/frontend)")
|
|
print(" - Créer une étape VWB par drag-and-drop")
|
|
print(" - Vérifier l'affichage des propriétés")
|
|
print()
|
|
|
|
def executer_tests(self):
|
|
"""Exécuter tous les tests"""
|
|
print("🚀 TESTS DES PROPRIÉTÉS D'ÉTAPES VWB")
|
|
print("=" * 50)
|
|
|
|
# Test 1: Backend catalogue
|
|
backend_ok = self.tester_backend_catalogue()
|
|
|
|
# Test 2: Composants frontend
|
|
composants_ok = self.verifier_composants_frontend()
|
|
|
|
# Test 3: Intégration complète
|
|
integration_ok = self.tester_integration_complete()
|
|
|
|
# Résumé
|
|
print("\n📊 RÉSUMÉ DES TESTS")
|
|
print("=" * 50)
|
|
print(f"Backend catalogue: {'✅' if backend_ok else '❌'}")
|
|
print(f"Composants frontend: {'✅' if composants_ok else '❌'}")
|
|
print(f"Intégration VWB: {'✅' if integration_ok else '❌'}")
|
|
|
|
# Diagnostic et solutions
|
|
if not (backend_ok and composants_ok and integration_ok):
|
|
self.diagnostiquer_problemes()
|
|
self.generer_solution()
|
|
else:
|
|
print("\n🎉 TOUS LES TESTS RÉUSSIS!")
|
|
print("Les propriétés d'étapes VWB devraient s'afficher correctement.")
|
|
|
|
return backend_ok and composants_ok and integration_ok
|
|
|
|
def main():
|
|
"""Fonction principale"""
|
|
print("Test des Propriétés d'Étapes 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 = VWBPropertiesTesteur()
|
|
succes = testeur.executer_tests()
|
|
|
|
# Sauvegarder les résultats
|
|
with open('tests/results/test_proprietes_etapes_vwb_10jan2026.json', 'w', encoding='utf-8') as f:
|
|
json.dump(testeur.resultats, f, indent=2, ensure_ascii=False)
|
|
|
|
print(f"\n📄 Résultats sauvegardés dans tests/results/test_proprietes_etapes_vwb_10jan2026.json")
|
|
|
|
sys.exit(0 if succes else 1)
|
|
|
|
if __name__ == "__main__":
|
|
main() |