v1.0 - Version stable: multi-PC, détection UI-DETR-1, 3 modes exécution

- 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>

tests/unit/test_circular_imports.py

@@ -0,0 +1,121 @@
+"""
+Tests pour la validation des imports circulaires.
+
+Auteur: Dom, Alice Kiro
+Date: 20 décembre 2024
+"""
+
+import pytest
+import sys
+from pathlib import Path
+
+# Ajouter le répertoire racine au path pour les imports
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from validate_circular_imports import CircularImportDetector
+
+
+class TestCircularImports:
+    """Tests pour la détection d'imports circulaires"""
+    
+    def test_no_circular_imports_in_core(self):
+        """Test qu'il n'y a pas d'imports circulaires dans core/"""
+        root_path = Path(__file__).parent.parent.parent
+        core_path = root_path / 'core'
+        
+        detector = CircularImportDetector(root_path)
+        detector.analyze_directory(core_path)
+        
+        cycles = detector.find_cycles()
+        
+        if cycles:
+            cycle_info = []
+            for i, cycle in enumerate(cycles, 1):
+                cycle_str = " → ".join(cycle)
+                cycle_info.append(f"Cycle {i}: {cycle_str}")
+            
+            pytest.fail(
+                f"Imports circulaires détectés:\n" + 
+                "\n".join(cycle_info) +
+                "\n\nSolutions:\n" +
+                "1. Utiliser TYPE_CHECKING pour les imports de type\n" +
+                "2. Déplacer les imports dans les fonctions (lazy loading)\n" +
+                "3. Créer des interfaces abstraites"
+            )
+    
+    def test_lazy_imports_available(self):
+        """Test que les fonctions de lazy loading sont disponibles"""
+        from core.models import (
+            get_workflow,
+            get_workflow_node,
+            get_action,
+            get_target_spec,
+            get_execution_result
+        )
+        
+        # Vérifier que les fonctions retournent les bonnes classes
+        Workflow = get_workflow()
+        assert Workflow.__name__ == 'Workflow'
+        
+        WorkflowNode = get_workflow_node()
+        assert WorkflowNode.__name__ == 'WorkflowNode'
+        
+        Action = get_action()
+        assert Action.__name__ == 'Action'
+        
+        TargetSpec = get_target_spec()
+        assert TargetSpec.__name__ == 'TargetSpec'
+        
+        ExecutionResult = get_execution_result()
+        assert ExecutionResult.__name__ == 'WorkflowExecutionResult'
+    
+    def test_interfaces_importable(self):
+        """Test que les interfaces abstraites sont importables"""
+        from core.interfaces import ITargetResolver, IActionExecutor, IErrorHandler
+        
+        # Vérifier que ce sont bien des classes abstraites
+        assert hasattr(ITargetResolver, '__abstractmethods__')
+        assert hasattr(IActionExecutor, '__abstractmethods__')
+        assert hasattr(IErrorHandler, '__abstractmethods__')
+        
+        # Vérifier qu'on ne peut pas les instancier directement
+        with pytest.raises(TypeError):
+            ITargetResolver()
+        
+        with pytest.raises(TypeError):
+            IActionExecutor()
+        
+        with pytest.raises(TypeError):
+            IErrorHandler()
+    
+    def test_type_checking_imports(self):
+        """Test que les imports TYPE_CHECKING fonctionnent"""
+        # Ceci ne devrait pas lever d'exception
+        from typing import TYPE_CHECKING
+        
+        if TYPE_CHECKING:
+            from core.models import (
+                Workflow,
+                WorkflowNode,
+                Action,
+                TargetSpec
+            )
+        
+        # Les imports conditionnels ne devraient pas être disponibles à l'exécution
+        import core.models as models
+        
+        # Ces attributs ne devraient pas être directement disponibles
+        assert not hasattr(models, 'Workflow')
+        assert not hasattr(models, 'WorkflowNode')
+        assert not hasattr(models, 'Action')
+        assert not hasattr(models, 'TargetSpec')
+        
+        # Mais les fonctions de lazy loading devraient être disponibles
+        assert hasattr(models, 'get_workflow')
+        assert hasattr(models, 'get_workflow_node')
+        assert hasattr(models, 'get_action')
+        assert hasattr(models, 'get_target_spec')
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])