rpa_vision_v3/tests/integration/test_imports_regression.py

"""
Tests de régression pour s'assurer que les corrections d'imports
n'ont pas cassé les fonctionnalités existantes.

Auteur: Dom, Alice Kiro
Date: 20 décembre 2024
"""

import pytest
import sys
from pathlib import Path

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


class TestImportsRegression:
    """Tests de régression pour les imports"""
    
    def test_basic_models_still_work(self):
        """Test que les modèles de base fonctionnent encore"""
        from core.models import RawSession, ScreenState, UIElement
        from datetime import datetime
        
        # Test création d'objets de base
        from core.models.screen_state import WindowContext, RawLevel, PerceptionLevel, ContextLevel, EmbeddingRef
        
        window = WindowContext(app_name='test', window_title='test', screen_resolution=[1920, 1080])
        raw = RawLevel(screenshot_path='test.png', capture_method='test', file_size_bytes=1024)
        embedding_ref = EmbeddingRef(provider='test', vector_id='test.npy', dimensions=512)
        perception = PerceptionLevel(
            embedding=embedding_ref,
            detected_text=['test'],
            text_detection_method='test',
            confidence_avg=0.9
        )
        context = ContextLevel()
        
        screen_state = ScreenState(
            screen_state_id='test_123',
            timestamp=datetime.now(),
            session_id='session_123',
            window=window,
            raw=raw,
            perception=perception,
            context=context
        )
        
        # Vérifier que les alias fonctionnent
        assert screen_state.state_id == 'test_123'
        assert screen_state.raw_level == raw
        assert screen_state.perception_level == perception
    
    def test_lazy_imports_work(self):
        """Test que les lazy imports fonctionnent"""
        from core.models import get_workflow, get_action, get_target_spec
        
        Workflow = get_workflow()
        Action = get_action()
        TargetSpec = get_target_spec()
        
        # Vérifier que ce sont les bonnes classes
        assert Workflow.__name__ == 'Workflow'
        assert Action.__name__ == 'Action'
        assert TargetSpec.__name__ == 'TargetSpec'
        
        # Test création d'objets
        target_spec = TargetSpec(by_role='button', by_text='Test Button')
        action = Action(type='mouse_click', target=target_spec)
        
        assert action.type == 'mouse_click'
        assert action.target.by_role == 'button'
    
    def test_storage_manager_works(self):
        """Test que StorageManager fonctionne encore"""
        from core.persistence.storage_manager import StorageManager
        
        storage = StorageManager()
        assert storage is not None
        
        # Test que les méthodes existent
        assert hasattr(storage, 'save_workflow')
        assert hasattr(storage, 'load_workflow')
        assert hasattr(storage, 'list_workflows')
    
    def test_interfaces_available(self):
        """Test que les interfaces abstraites sont disponibles"""
        from core.interfaces import ITargetResolver, IActionExecutor, IErrorHandler
        
        # Vérifier qu'elles sont abstraites
        assert hasattr(ITargetResolver, '__abstractmethods__')
        assert hasattr(IActionExecutor, '__abstractmethods__')
        assert hasattr(IErrorHandler, '__abstractmethods__')
        
        # Vérifier qu'on ne peut pas les instancier
        with pytest.raises(TypeError):
            ITargetResolver()
        with pytest.raises(TypeError):
            IActionExecutor()
        with pytest.raises(TypeError):
            IErrorHandler()
    
    def test_type_checking_works(self):
        """Test que TYPE_CHECKING fonctionne correctement"""
        import core.models as models

        # Les types workflow_graph ne sont pas importés directement au niveau module,
        # mais sont disponibles via __getattr__ (lazy loading). Vérifier que
        # les noms ne sont PAS dans le namespace direct du module (vars()),
        # mais sont accessibles via __getattr__ pour le lazy loading.
        module_vars = vars(models)
        assert 'Workflow' not in module_vars, "Workflow ne devrait pas être dans les attributs directs du module"
        assert 'Action' not in module_vars, "Action ne devrait pas être dans les attributs directs du module"
        assert 'TargetSpec' not in module_vars, "TargetSpec ne devrait pas être dans les attributs directs du module"

        # Les lazy imports explicites devraient être disponibles
        assert hasattr(models, 'get_workflow')
        assert hasattr(models, 'get_action')
        assert hasattr(models, 'get_target_spec')

        # Le lazy loading via __getattr__ doit fonctionner
        Workflow = models.Workflow
        assert Workflow.__name__ == 'Workflow'
    
    def test_existing_imports_still_work(self):
        """Test que les imports existants dans d'autres modules fonctionnent"""
        # Ces imports directs devraient encore fonctionner
        from core.models.workflow_graph import Workflow, Action, TargetSpec
        from core.models.screen_state import ScreenState
        from core.models.ui_element import UIElement
        
        # Vérifier que ce sont les bonnes classes
        assert Workflow.__name__ == 'Workflow'
        assert Action.__name__ == 'Action'
        assert TargetSpec.__name__ == 'TargetSpec'
        assert ScreenState.__name__ == 'ScreenState'
        assert UIElement.__name__ == 'UIElement'
    
    def test_serialization_still_works(self):
        """Test que la sérialisation/désérialisation fonctionne encore"""
        from core.models import get_action, get_target_spec
        
        Action = get_action()
        TargetSpec = get_target_spec()
        
        # Créer un objet
        target_spec = TargetSpec(by_role='button', by_text='Test Button')
        action = Action(type='mouse_click', target=target_spec)
        
        # Sérialiser
        action_dict = action.to_dict()
        assert action_dict['type'] == 'mouse_click'
        assert action_dict['target']['by_role'] == 'button'
        
        # Désérialiser
        action_restored = Action.from_dict(action_dict)
        assert action_restored.type == 'mouse_click'
        assert action_restored.target.by_role == 'button'


if __name__ == "__main__":
    pytest.main([__file__, "-v"])