#!/usr/bin/env python3 """ Test rapide du système RPA Vision V3 après corrections Tests de fonctionnalité réelle sans simulation """ import sys import os import tempfile import shutil import numpy as np from pathlib import Path # Ajouter le répertoire racine au path sys.path.insert(0, str(Path(__file__).parent)) def test_core_functionality(): """Test de la fonctionnalité réelle des composants critiques""" print("🧪 Test de fonctionnalité réelle des composants...") # Test 1: FAISSManager avec opérations réelles try: from core.embedding.faiss_manager import FAISSManager # Créer un manager réel manager = FAISSManager(dimensions=512) # Test d'ajout d'embedding réel test_vector = np.random.randn(512).astype(np.float32) faiss_id = manager.add_embedding("test_emb_1", test_vector, {"test": True}) # Test de recherche réelle results = manager.search_similar(test_vector, k=1) if len(results) > 0 and results[0].embedding_id == "test_emb_1": print("✅ FAISSManager - Fonctionnalité réelle validée") else: print("❌ FAISSManager - Recherche échouée") return False except Exception as e: print(f"❌ FAISSManager: {e}") return False # Test 2: StorageManager avec opérations réelles sur fichiers try: from core.persistence import StorageManager # Utiliser un répertoire temporaire réel with tempfile.TemporaryDirectory() as temp_dir: storage = StorageManager(base_path=temp_dir) # Test de sauvegarde réelle d'embedding test_embedding = np.random.randn(512).astype(np.float32) embedding_path = storage.save_embedding( "test_session", "test_state", test_embedding, {"test_meta": "value"} ) # Vérifier que le fichier existe réellement if not Path(embedding_path).exists(): print("❌ StorageManager - Fichier non créé") return False # Test de chargement réel loaded_embedding, loaded_metadata = storage.load_embedding(embedding_path) # Vérifier que les données sont identiques if not np.allclose(test_embedding, loaded_embedding): print("❌ StorageManager - Données corrompues") return False print("✅ StorageManager - Fonctionnalité réelle validée") except Exception as e: print(f"❌ StorageManager: {e}") return False # Test 3: ProcessingPipeline avec données réelles try: from server.processing_pipeline import ProcessingPipeline # Créer un pipeline réel pipeline = ProcessingPipeline() # Test avec des données réelles minimales test_session_data = { "session_id": "test_session_001", "events": [ { "type": "mouse_click", "timestamp": 1234567890, "x": 100, "y": 200 } ], "screenshots": [] } # Valider que le pipeline peut traiter des données réelles is_valid = pipeline.validate_session_data(test_session_data) if is_valid: print("✅ ProcessingPipeline - Validation réelle réussie") else: print("❌ ProcessingPipeline - Validation échouée") return False except Exception as e: print(f"❌ ProcessingPipeline: {e}") return False # Test 4: Modèles de données avec instanciation réelle try: from core.models import RawSession, ScreenState, UIElement # Test RawSession avec données réelles raw_session = RawSession( session_id="test_session", user_id="test_user", started_at="2025-01-06T10:00:00Z", events=[], screenshots=[] ) # Vérifier que l'objet est utilisable if raw_session.session_id != "test_session": print("❌ RawSession - Instanciation échouée") return False # Test UIElement avec données réelles ui_element = UIElement( element_id="test_element", element_type="button", bbox=[10, 20, 100, 50], text="Test Button", confidence=0.95 ) # Vérifier les propriétés calculées if ui_element.center != (60, 45): # Centre calculé print("❌ UIElement - Calculs échoués") return False print("✅ Modèles de données - Instanciation réelle validée") except Exception as e: print(f"❌ Modèles de données: {e}") return False return True def test_real_env_config(): """Test de la configuration d'environnement avec chargement réel""" print("\n🔧 Test configuration environnement réelle...") env_path = Path(".env.local") if not env_path.exists(): print("❌ .env.local manquant") return False # Test de chargement réel des variables d'environnement try: import os from dotenv import load_dotenv # Sauvegarder l'état actuel original_env = dict(os.environ) # Charger le fichier .env.local réellement load_dotenv(env_path) # Vérifier que les variables sont réellement chargées auth_disabled = os.getenv("RPA_AUTH_DISABLED", "true").lower() encryption_password = os.getenv("ENCRYPTION_PASSWORD", "") if auth_disabled == "false": print("✅ Authentification activée (chargée depuis .env)") else: print("⚠️ Authentification désactivée") if encryption_password: print("✅ Mot de passe de chiffrement configuré et chargé") else: print("❌ Mot de passe de chiffrement manquant ou vide") return False # Test de validation de la configuration de sécurité try: from core.security.security_config import SecurityConfig # Créer une configuration réelle security_config = SecurityConfig() # Vérifier que la configuration est valide if security_config.validate(): print("✅ Configuration de sécurité validée") else: print("⚠️ Configuration de sécurité invalide") except Exception as e: print(f"⚠️ SecurityConfig non disponible: {e}") # Restaurer l'environnement original os.environ.clear() os.environ.update(original_env) return True except ImportError: print("⚠️ python-dotenv non installé, test de base seulement") # Test de base sans dotenv with open(env_path, 'r') as f: content = f.read() if "RPA_AUTH_DISABLED=false" in content: print("✅ Authentification activée (fichier)") else: print("⚠️ Authentification désactivée") if "ENCRYPTION_PASSWORD=" in content and len(content.split("ENCRYPTION_PASSWORD=")[1].split('\n')[0].strip()) > 0: print("✅ Mot de passe de chiffrement configuré (fichier)") else: print("❌ Mot de passe de chiffrement manquant") return False return True except Exception as e: print(f"❌ Erreur lors du test de configuration: {e}") return False def test_real_directories_and_permissions(): """Test des répertoires avec vérification des permissions réelles""" print("\n📁 Test des répertoires et permissions...") dirs_to_test = [ ("data/training/uploads", True), # (path, should_be_writable) ("data/training/sessions", True), ("logs", True), ("venv_v3", False), # Virtual env, just check existence ("core", False), # Core modules, read-only ] all_ok = True for dir_path, should_be_writable in dirs_to_test: path_obj = Path(dir_path) if not path_obj.exists(): print(f"❌ {dir_path} - N'existe pas") all_ok = False continue if not path_obj.is_dir(): print(f"❌ {dir_path} - N'est pas un répertoire") all_ok = False continue # Test des permissions réelles if should_be_writable: try: # Test d'écriture réel avec un fichier temporaire test_file = path_obj / ".test_write_permission" test_file.write_text("test") test_file.unlink() # Supprimer le fichier de test print(f"✅ {dir_path} - Accessible en écriture") except Exception as e: print(f"❌ {dir_path} - Pas d'accès en écriture: {e}") all_ok = False else: # Test de lecture seulement try: list(path_obj.iterdir()) # Essayer de lister le contenu print(f"✅ {dir_path} - Accessible en lecture") except Exception as e: print(f"❌ {dir_path} - Pas d'accès en lecture: {e}") all_ok = False # Test spécifique: Vérifier que les répertoires de données peuvent stocker des fichiers réels try: test_data_dir = Path("data/training/uploads") if test_data_dir.exists(): # Créer un fichier de test réaliste test_session_file = test_data_dir / "test_session.json" test_data = { "session_id": "test_001", "timestamp": "2025-01-06T10:00:00Z", "events": [] } import json test_session_file.write_text(json.dumps(test_data, indent=2)) # Vérifier que le fichier peut être lu loaded_data = json.loads(test_session_file.read_text()) if loaded_data["session_id"] == "test_001": print("✅ Test d'écriture/lecture de données réelles réussi") test_session_file.unlink() # Nettoyer else: print("❌ Test d'écriture/lecture de données échoué") all_ok = False except Exception as e: print(f"❌ Test d'écriture/lecture de données: {e}") all_ok = False return all_ok def test_integration_flow(): """Test d'un flux d'intégration réel simplifié""" print("\n🔄 Test de flux d'intégration réel...") try: # Test 1: Créer une session réelle avec StorageManager from core.persistence import StorageManager from core.models import RawSession with tempfile.TemporaryDirectory() as temp_dir: storage = StorageManager(base_path=temp_dir) # Créer une session réelle session = RawSession( session_id="integration_test_001", user_id="test_user", started_at="2025-01-06T10:00:00Z", events=[ { "type": "mouse_click", "timestamp": 1234567890, "x": 150, "y": 250, "button": "left" } ], screenshots=[] ) # Sauvegarder la session réellement session_path = storage.save_raw_session(session) if not Path(session_path).exists(): print("❌ Sauvegarde de session échouée") return False # Charger la session et vérifier l'intégrité loaded_session = storage.load_raw_session(session_path) if loaded_session.session_id != session.session_id: print("❌ Intégrité de session compromise") return False print("✅ Flux session: sauvegarde/chargement réussi") # Test 2: Pipeline de traitement avec données réelles from server.processing_pipeline import ProcessingPipeline pipeline = ProcessingPipeline() # Simuler un traitement réel avec validation test_data = { "session_id": "integration_test_002", "events": [ { "type": "key_press", "timestamp": 1234567891, "key": "Enter" } ] } # Valider avec le pipeline réel validation_result = pipeline.validate_session_data(test_data) if not validation_result: print("❌ Validation pipeline échouée") return False print("✅ Pipeline: validation de données réussie") # Test 3: Intégration FAISS + Storage from core.embedding.faiss_manager import FAISSManager faiss_manager = FAISSManager(dimensions=128) # Plus petit pour le test # Créer des embeddings réels et les stocker embeddings_data = [] for i in range(5): embedding = np.random.randn(128).astype(np.float32) embedding_id = f"integration_emb_{i}" # Ajouter à FAISS faiss_id = faiss_manager.add_embedding(embedding_id, embedding) embeddings_data.append((embedding_id, embedding, faiss_id)) # Test de recherche d'intégration query_embedding = embeddings_data[2][1] # Utiliser le 3ème embedding results = faiss_manager.search_similar(query_embedding, k=3) if len(results) == 0: print("❌ Recherche FAISS échouée") return False # Vérifier que le résultat le plus similaire est correct if results[0].embedding_id != embeddings_data[2][0]: print("❌ Recherche FAISS imprécise") return False print("✅ Intégration FAISS: recherche réussie") return True except Exception as e: print(f"❌ Flux d'intégration: {e}") return False def main(): print("🔧 RPA Vision V3 - Test Système avec Fonctionnalité Réelle") print("=" * 60) tests = [ ("Fonctionnalité Core", test_core_functionality), ("Configuration Réelle", test_real_env_config), ("Répertoires & Permissions", test_real_directories_and_permissions), ("Flux d'Intégration", test_integration_flow) ] results = [] for name, test_func in tests: try: print(f"\n🔍 Exécution: {name}") result = test_func() results.append((name, result)) except Exception as e: print(f"❌ Erreur dans {name}: {e}") import traceback traceback.print_exc() results.append((name, False)) print("\n" + "=" * 60) print("📊 RÉSULTATS FINAUX:") all_passed = True for name, passed in results: status = "✅ PASS" if passed else "❌ FAIL" print(f" {name}: {status}") if not passed: all_passed = False print("\n" + "=" * 60) if all_passed: print("🎉 TOUS LES TESTS DE FONCTIONNALITÉ RÉELLE PASSENT !") print("\n🚀 Le système est validé avec:") print(" • Opérations FAISS réelles") print(" • Stockage de fichiers réel") print(" • Configuration chargée réellement") print(" • Permissions vérifiées") print(" • Flux d'intégration testé") print(f"\n🎯 Prêt pour le lancement:") print(f" ./run.sh --server") return 0 else: print("⚠️ CERTAINS TESTS DE FONCTIONNALITÉ ÉCHOUENT") print("Vérifiez les erreurs détaillées ci-dessus") print("\n💡 Conseils de dépannage:") print(" • Vérifiez que les dépendances sont installées") print(" • Vérifiez les permissions des répertoires") print(" • Vérifiez la configuration .env.local") return 1 if __name__ == "__main__": sys.exit(main())