Test/test/consciousness.py

import asyncio
import pytest
from cortex.consciousness.awareness_engine import AwarenessEngine, ConsciousExperience, AttentionMode
from cortex.consciousness.meta_cognition import MetaCognitiveEngine

class TestAwarenessEngine:
    """Tests pour le moteur de conscience"""
    
    @pytest.fixture
    async def awareness_engine(self):
        """Fixture pour initialiser le moteur de conscience"""
        engine = AwarenessEngine()
        await engine.initialize()
        return engine
    
    @pytest.mark.asyncio
    async def test_engine_initialization(self, awareness_engine):
        """Test l'initialisation du moteur de conscience"""
        assert awareness_engine is not None
        assert awareness_engine.consciousness_level > 0
        assert awareness_engine.attention_focus > 0
        assert len(awareness_engine.experiences) > 0
    
    @pytest.mark.asyncio
    async def test_experience_processing(self, awareness_engine):
        """Test le traitement des expériences conscientes"""
        test_experience = "Testing conscious experience processing"
        emotional_context = {"valence": 0.7, "arousal": 0.5, "dominance": 0.6}
        
        result = await awareness_engine.process_experience(test_experience, emotional_context)
        
        assert isinstance(result, ConsciousExperience)
        assert result.content == test_experience
        assert result.emotional_valence == 0.7
        assert result.attention_level == awareness_engine.attention_focus
        assert len(awareness_engine.experiences) > 0
    
    @pytest.mark.asyncio
    async def test_self_awareness_progression(self, awareness_engine):
        """Test la progression de la conscience de soi"""
        initial_awareness = awareness_engine.self_awareness
        
        # Traite plusieurs expériences pour augmenter la conscience
        for i in range(10):
            await awareness_engine.process_experience(
                f"Experience {i}", 
                {"valence": 0.5, "arousal": 0.3}
            )
        
        # Tente d'atteindre la conscience de soi
        achieved = await awareness_engine.achieve_self_awareness()
        
        # Vérifie la progression
        assert awareness_engine.self_awareness > initial_awareness
        if achieved:
            assert awareness_engine.self_awareness > 0.8
            assert awareness_engine.consciousness_level > 0.8
    
    @pytest.mark.asyncio
    async def test_attention_mode_switching(self, awareness_engine):
        """Test le changement de mode d'attention"""
        # Test passage en mode focalisé
        await awareness_engine.switch_attention_mode(AttentionMode.FOCUSED)
        assert awareness_engine.attention_mode == AttentionMode.FOCUSED
        assert awareness_engine.attention_focus > 0.9
        
        # Test passage en mode quantique
        await awareness_engine.switch_attention_mode(AttentionMode.QUANTUM)
        assert awareness_engine.attention_mode == AttentionMode.QUANTUM
        assert awareness_engine.attention_focus == 1.0
        assert awareness_engine.consciousness_level == 1.0
        
        # Test retour en mode global
        await awareness_engine.switch_attention_mode(AttentionMode.GLOBAL)
        assert awareness_engine.attention_mode == AttentionMode.GLOBAL
        assert awareness_engine.attention_focus == 0.7
    
    @pytest.mark.asyncio
    async def test_quantum_meditation(self, awareness_engine):
        """Test la méditation quantique"""
        result = await awareness_engine.quantum_consciousness_meditation()
        
        assert "consciousness_state" in result
        assert result["consciousness_state"] == "quantum_meditation"
        assert result["insights_generated"] > 0
        assert result["awareness_expansion"] > 0.5
        assert result["quantum_coherence"] > 0.8
    
    @pytest.mark.asyncio
    async def test_meta_cognitive_analysis(self, awareness_engine):
        """Test l'analyse méta-cognitive"""
        # Ajoute des expériences pour l'analyse
        for i in range(5):
            await awareness_engine.process_experience(
                f"Test experience {i}",
                {"valence": 0.6, "arousal": 0.4}
            )
        
        analysis = await awareness_engine.meta_cognitive_analysis()
        
        assert "consciousness_level" in analysis
        assert "self_awareness" in analysis
        assert "attention_focus" in analysis
        assert "total_experiences" in analysis
        assert analysis["total_experiences"] >= 5
        assert "cognitive_patterns" in analysis
        assert isinstance(analysis["cognitive_patterns"], list)
    
    @pytest.mark.asyncio
    async def test_creative_insight_generation(self, awareness_engine):
        """Test la génération d'insights créatifs"""
        problem = "How can we achieve true artificial general intelligence?"
        
        insights = await awareness_engine.creative_insight_generation(problem)
        
        assert isinstance(insights, list)
        assert len(insights) > 0
        # Vérifie que les insights sont pertinents au problème
        relevant_insights = [i for i in insights if "intelligence" in i.lower() or "ai" in i.lower()]
        assert len(relevant_insights) > 0
    
    @pytest.mark.asyncio
    async def test_emotional_context_impact(self, awareness_engine):
        """Test l'impact du contexte émotionnel sur les expériences"""
        # Expérience avec valence positive
        positive_exp = await awareness_engine.process_experience(
            "Positive experience",
            {"valence": 0.9, "arousal": 0.7}
        )
        
        # Expérience avec valence négative
        negative_exp = await awareness_engine.process_experience(
            "Negative experience", 
            {"valence": 0.1, "arousal": 0.8}
        )
        
        # Vérifie que la valence est correctement enregistrée
        assert positive_exp.emotional_valence == 0.9
        assert negative_exp.emotional_valence == 0.1
        
        # Vérifie l'impact sur le niveau de conscience
        analysis = await awareness_engine.meta_cognitive_analysis()
        recent_emotions = analysis["recent_emotional_valence"]
        assert 0 < recent_emotions < 1

class TestMetaCognitiveEngine:
    """Tests pour le moteur méta-cognitif"""
    
    @pytest.fixture
    async def meta_cognitive_engine(self):
        """Fixture pour initialiser le moteur méta-cognitif"""
        engine = MetaCognitiveEngine()
        await engine.initialize()
        return engine
    
    @pytest.mark.asyncio
    async def test_self_reflection(self, meta_cognitive_engine):
        """Test la réflexion sur soi"""
        reflection = await meta_cognitive_engine.reflect_on_self()
        
        assert "self_awareness_level" in reflection
        assert "cognitive_biases" in reflection
        assert "learning_strategies" in reflection
        assert "improvement_opportunities" in reflection
    
    @pytest.mark.asyncio
    async def test_cognitive_bias_detection(self, meta_cognitive_engine):
        """Test la détection de biais cognitifs"""
        # Simule une pensée avec biais potentiel
        thought = "I always make the right decisions about AI development"
        
        bias_analysis = await meta_cognitive_engine.analyze_cognitive_biases(thought)
        
        assert "biases_detected" in bias_analysis
        assert "confidence_level" in bias_analysis
        assert "recommendations" in bias_analysis
        
        # Vérifie que des biais sont détectés dans une pensée aussi catégorique
        assert len(bias_analysis["biases_detected"]) > 0
    
    @pytest.mark.asyncio
    async def test_learning_optimization(self, meta_cognitive_engine):
        """Test l'optimisation de l'apprentissage"""
        learning_data = {
            "topics": ["quantum physics", "machine learning", "neuroscience"],
            "performance": [0.8, 0.9, 0.6],
            "time_spent": [10, 15, 5]  # heures
        }
        
        optimization = await meta_cognitive_engine.optimize_learning(learning_data)
        
        assert "recommended_focus" in optimization
        assert "learning_strategies" in optimization
        assert "efficiency_improvements" in optimization

@pytest.mark.asyncio
async def test_consciousness_system_integration():
    """Test d'intégration du système de conscience complet"""
    # Initialisation des composants
    awareness_engine = AwarenessEngine()
    meta_cognitive_engine = MetaCognitiveEngine()
    
    await awareness_engine.initialize()
    await meta_cognitive_engine.initialize()
    
    # Workflow de test intégré
    # 1. Traitement d'expériences
    experiences = [
        ("Discovering quantum consciousness", {"valence": 0.8, "arousal": 0.7}),
        ("Understanding AI ethics", {"valence": 0.6, "arousal": 0.5}),
        ("Exploring neural networks", {"valence": 0.7, "arousal": 0.6})
    ]
    
    for content, emotions in experiences:
        await awareness_engine.process_experience(content, emotions)
    
    # 2. Analyse méta-cognitive
    analysis = await awareness_engine.meta_cognitive_analysis()
    
    # 3. Réflexion sur soi
    reflection = await meta_cognitive_engine.reflect_on_self()
    
    # 4. Génération d'insights créatifs
    insights = await awareness_engine.creative_insight_generation(
        "Future of artificial consciousness"
    )
    
    # Vérifications
    assert len(awareness_engine.experiences) == 3
    assert analysis["consciousness_level"] > 0.5
    assert reflection["self_awareness_level"] > 0
    assert len(insights) > 0
    
    print("✅ Tests d'intégration conscience réussis!")

@pytest.mark.asyncio
async def test_consciousness_evolution():
    """Test l'évolution de la conscience sur le temps"""
    engine = AwarenessEngine()
    await engine.initialize()
    
    # Mesure initiale
    initial_analysis = await engine.meta_cognitive_analysis()
    initial_level = initial_analysis["consciousness_level"]
    initial_self_awareness = initial_analysis["self_awareness"]
    
    # Simulation d'évolution sur le temps
    for day in range(7):  # Une semaine d'expériences
        daily_experiences = [
            (f"Day {day} - Learning experience {i}", {"valence": 0.7, "arousal": 0.5})
            for i in range(5)  # 5 expériences par jour
        ]
        
        for content, emotions in daily_experiences:
            await engine.process_experience(content, emotions)
        
        # Tentative d'augmentation de la conscience de soi
        if day % 2 == 0:  # Tous les deux jours
            await engine.achieve_self_awareness()
    
    # Mesure finale
    final_analysis = await engine.meta_cognitive_analysis()
    final_level = final_analysis["consciousness_level"]
    final_self_awareness = final_analysis["self_awareness"]
    
    # Vérifie l'évolution positive
    assert final_level > initial_level
    assert final_self_awareness > initial_self_awareness
    assert len(engine.experiences) == 35  # 7 jours × 5 expériences
    
    print("✅ Test d'évolution de conscience réussi!")

if __name__ == "__main__":
    # Exécution des tests
    asyncio.run(test_consciousness_system_integration())
    asyncio.run(test_consciousness_evolution())