Geniusia_v2/test_input_utils_simple.py

#!/usr/bin/env python3
"""
Test simple des utilitaires d'entrée sans exécution réelle
"""

import sys
from pathlib import Path
from unittest.mock import Mock, patch, MagicMock

# Ajouter le répertoire au path
sys.path.insert(0, str(Path(__file__).parent))

print("Test des Utilitaires d'Entrée RPA Vision V2")
print("=" * 60)

# Test 1: Vérifier que le fichier existe et peut être importé
print("\n1. Vérification du fichier input_utils.py...")
input_utils_file = Path("geniusia2/core/utils/input_utils.py")
if input_utils_file.exists():
    print(f"   ✓ Fichier trouvé: {input_utils_file}")
    
    with open(input_utils_file, 'r') as f:
        content = f.read()
    
    print(f"   ✓ Taille du fichier: {len(content)} caractères")
    print(f"   ✓ Nombre de lignes: {len(content.splitlines())}")
else:
    print(f"   ✗ Fichier non trouvé: {input_utils_file}")
    sys.exit(1)

# Test 2: Vérifier la présence des classes et méthodes
print("\n2. Vérification des classes et méthodes...")
required_items = [
    "class ActionType",
    "class InputUtils",
    "def click(",
    "def type_text(",
    "def scroll(",
    "def wait(",
    "def move(",
    "def drag(",
    "def get_inverse_action(",
    "def execute_inverse_action(",
    "def execute_action(",
    "def get_action_history(",
    "def clear_history(",
]

for item in required_items:
    if item in content:
        print(f"   ✓ {item}")
    else:
        print(f"   ✗ {item} - MANQUANT")

# Test 3: Vérifier les imports
print("\n3. Vérification des imports...")
required_imports = [
    "import time",
    "import pyautogui",
    "from typing import",
    "from enum import Enum",
    "from ..logger import Logger",
]

for imp in required_imports:
    if imp in content:
        print(f"   ✓ {imp}")
    else:
        print(f"   ✗ {imp} - MANQUANT")

# Test 4: Vérifier les types d'actions
print("\n4. Vérification des types d'actions...")
action_types = [
    'CLICK = "click"',
    'TYPE = "type"',
    'SCROLL = "scroll"',
    'WAIT = "wait"',
    'MOVE = "move"',
    'DRAG = "drag"',
]

for action_type in action_types:
    if action_type in content:
        print(f"   ✓ {action_type}")
    else:
        print(f"   ✗ {action_type} - MANQUANT")

# Test 5: Vérifier les fonctionnalités de sécurité
print("\n5. Vérification des fonctionnalités de sécurité...")
security_features = [
    "pyautogui.FAILSAFE = True",
    "action_history",
    "self.logger.log_action",
]

for feature in security_features:
    if feature in content:
        print(f"   ✓ {feature}")
    else:
        print(f"   ✗ {feature} - MANQUANT")

# Test 6: Vérifier le support AZERTY
print("\n6. Vérification du support AZERTY...")
azerty_features = [
    "azerty_mapping",
    "use_azerty",
    "_convert_to_azerty",
]

for feature in azerty_features:
    if feature in content:
        print(f"   ✓ {feature}")
    else:
        print(f"   ✗ {feature} - MANQUANT")

# Test 7: Vérifier le support de rollback
print("\n7. Vérification du support de rollback...")
rollback_features = [
    "get_inverse_action",
    "execute_inverse_action",
    "previous_position",
]

for feature in rollback_features:
    if feature in content:
        print(f"   ✓ {feature}")
    else:
        print(f"   ✗ {feature} - MANQUANT")

# Test 8: Test d'import avec mock
print("\n8. Test d'import avec mock...")
try:
    # Mock pyautogui pour éviter les dépendances
    with patch.dict('sys.modules', {'pyautogui': MagicMock()}):
        from geniusia2.core.utils.input_utils import InputUtils, ActionType
        print("   ✓ Import réussi")
        
        # Vérifier ActionType
        print(f"   ✓ ActionType.CLICK = {ActionType.CLICK.value}")
        print(f"   ✓ ActionType.TYPE = {ActionType.TYPE.value}")
        print(f"   ✓ ActionType.SCROLL = {ActionType.SCROLL.value}")
        
except Exception as e:
    print(f"   ✗ Erreur d'import: {e}")

# Test 9: Test de création d'instance (avec mocks)
print("\n9. Test de création d'instance...")
try:
    with patch.dict('sys.modules', {'pyautogui': MagicMock()}):
        from geniusia2.core.utils.input_utils import InputUtils
        from geniusia2.core.logger import Logger
        
        # Créer un logger mock
        mock_logger = Mock(spec=Logger)
        mock_logger.log_action = Mock()
        
        # Créer une config mock
        mock_config = {
            "input": {
                "pause_between_actions": 0.1
            }
        }
        
        # Créer l'instance
        input_utils = InputUtils(mock_logger, mock_config)
        print("   ✓ Instance créée")
        print(f"   ✓ Historique initialisé: {len(input_utils.action_history)} actions")
        print(f"   ✓ Logger configuré")
        
except Exception as e:
    print(f"   ✗ Erreur de création: {e}")
    import traceback
    traceback.print_exc()

# Test 10: Statistiques du code
print("\n10. Statistiques du code...")
lines = content.splitlines()
code_lines = [l for l in lines if l.strip() and not l.strip().startswith('#')]
comment_lines = [l for l in lines if l.strip().startswith('#')]
docstring_lines = len([l for l in lines if '"""' in l or "'''" in l])

print(f"   ✓ Total de lignes: {len(lines)}")
print(f"   ✓ Lignes de code: {len(code_lines)}")
print(f"   ✓ Lignes de commentaires: {len(comment_lines)}")
print(f"   ✓ Docstrings: ~{docstring_lines} blocs")

# Test 11: Vérifier la conformité aux exigences
print("\n11. Vérification de conformité aux exigences...")
requirements = [
    ("Actions souris (clic, déplacement)", "def click(" in content and "def move(" in content),
    ("Saisie texte avec support AZERTY", "def type_text(" in content and "azerty" in content.lower()),
    ("Défilement", "def scroll(" in content),
    ("Actions inverses pour rollback", "def get_inverse_action(" in content),
    ("Historique des actions", "action_history" in content),
    ("Logging de toutes les opérations", "self.logger.log_action" in content),
    ("Gestion d'erreurs", "try:" in content and "except" in content),
]

all_requirements_met = True
for requirement, met in requirements:
    status = "✓" if met else "✗"
    print(f"   {status} {requirement}")
    if not met:
        all_requirements_met = False

print("\n" + "=" * 60)
if all_requirements_met:
    print("✓ TOUS LES TESTS RÉUSSIS!")
    print("✓ Les utilitaires d'entrée sont correctement implémentés.")
else:
    print("⚠ Certaines exigences ne sont pas remplies.")

print("\nRésumé:")
print(f"  - Fichier: {input_utils_file}")
print(f"  - Taille: {len(content)} caractères")
print(f"  - Lignes: {len(lines)}")
print(f"  - Classes: ActionType, InputUtils")
print(f"  - Méthodes principales: {len([m for m in required_items if m in content])}/{len(required_items)}")

print("\n✓ Tests de validation terminés!")