80% coverage on tests

Author: bordumb

.github/workflows/ci.yml

@@ -9,83 +9,26 @@ on:
     branches: [main]
 
 jobs:
-  lint-and-format:
-    name: "Lint & Format"
+  ci:
+    # The job name will be dynamically set based on the matrix task name
+    name: ${{ matrix.task.name }}
     runs-on: ubuntu-latest
-    steps:
-      - name: "Checkout code"
-        uses: actions/checkout@v4
-
-      - name: "Set up Python"
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11.9"
-
-      - name: "Install Poetry"
-        run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-          echo "$HOME/.local/bin" >> $GITHUB_PATH
-
-      - name: "Configure Poetry"
-        run: |
-          poetry config virtualenvs.create true
-          poetry config virtualenvs.in-project true
-
-      - name: "Cache Poetry dependencies"
-        uses: actions/cache@v4
-        with:
-          path: .venv
-          key: poetry-${{ runner.os }}-${{ hashFiles('**/poetry.lock') }}
-          restore-keys: |
-            poetry-${{ runner.os }}-
-
-      - name: "Install dependencies"
-        run: poetry install
-
-      - name: "Run Linter & Formatter"
-        run: |
-          poetry run ruff check .
-          poetry run ruff format --check .
-
-  type-check:
-    name: "Type Checking"
-    runs-on: ubuntu-latest
-    steps:
-      - name: "Checkout code"
-        uses: actions/checkout@v4
-
-      - name: "Set up Python"
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11.9"
-
-      - name: "Install Poetry"
-        run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-          echo "$HOME/.local/bin" >> $GITHUB_PATH
-
-      - name: "Configure Poetry"
-        run: |
-          poetry config virtualenvs.create true
-          poetry config virtualenvs.in-project true
-
-      - name: "Cache Poetry dependencies"
-        uses: actions/cache@v4
-        with:
-          path: .venv
-          key: poetry-${{ runner.os }}-${{ hashFiles('**/poetry.lock') }}
-          restore-keys: |
-            poetry-${{ runner.os }}-
-
-      - name: "Install dependencies"
-        run: poetry install
+    strategy:
+      # This ensures that if one matrix job fails, the others will continue to run
+      fail-fast: false
+      matrix:
+        task:
+          - name: "Lint & Format"
+            run_command: |
+              poetry run ruff check .
+              poetry run ruff format --check .
+          - name: "Type Checking"
+            run_command: poetry run mypy agent-core agent-engine agent-concurrent agent-persist agent-sim
+          - name: "Run Tests & Check Coverage"
+            run_command: poetry run pytest --cov=agent_core --cov=agent_engine --cov-report=term-missing --cov-fail-under=80
+            # Add a flag to indicate that this specific task needs graphviz
+            needs_graphviz: true
 
-      - name: "Run Type Checker"
-        run: poetry run mypy agent-core agent-engine agent-concurrent agent-persist agent-sim
-
-  test:
-    name: "Run Tests & Check Coverage"
-    runs-on: ubuntu-latest
     steps:
       - name: "Checkout code"
         uses: actions/checkout@v4
@@ -95,7 +38,9 @@ jobs:
         with:
           python-version: "3.11.9"
 
+      # This step will only run for the "Run Tests & Check Coverage" job
       - name: "Install Graphviz"
+        if: matrix.task.needs_graphviz == true
         run: |
           sudo apt-get update
           sudo apt-get install -y graphviz graphviz-dev libgraphviz-dev pkg-config
@@ -121,5 +66,5 @@ jobs:
       - name: "Install dependencies"
         run: poetry install
 
-      - name: "Run Tests and Check Coverage"
-        run: poetry run pytest --cov=agent_core --cov=agent_engine --cov-report=term-missing --cov-fail-under=80
+      - name: "Run Task"
+        run: ${{ matrix.task.run_command }}

tests/agent_core/core/ecs/test_component.py

@@ -1,63 +1,154 @@
-# tests/agent_core/core/ecs/test_component.py
-"""
-Unit tests for core ECS components in agent_core.
-"""
+# tests/agent-core/core/ecs/test_components.py
 
-import pytest
-from agent_core.core.ecs.component import ValidationComponent
+from agent_core.core.ecs.component import (
+    ActionOutcomeComponent,
+    ActionPlanComponent,
+    AffectComponent,
+    BeliefSystemComponent,
+    CompetenceComponent,
+    EmotionComponent,
+    GoalComponent,
+    TimeBudgetComponent,
+)
 
 
-class TestValidationComponent:
-    """Tests for the ValidationComponent."""
+class TestTimeBudgetComponent:
+    """Tests for the TimeBudgetComponent."""
 
-    def test_initialization(self):
-        """Tests that the component initializes with default values."""
-        comp = ValidationComponent()
-        assert comp.reflection_confidence_scores == {}
-        assert comp.causal_model_confidence == 0.0
+    def test_validation_success(self):
+        """Test that a valid component passes validation."""
+        comp = TimeBudgetComponent(initial_time_budget=100.0)
+        is_valid, errors = comp.validate("agent_1")
+        assert is_valid
+        assert not errors
 
-    def test_to_dict(self):
-        """Tests the serialization of the component's state."""
-        comp = ValidationComponent()
-        comp.reflection_confidence_scores = {10: 0.8}
-        comp.causal_model_confidence = 0.95
+    def test_validation_failure_negative_budget(self):
+        """Test that a negative current budget fails validation."""
+        comp = TimeBudgetComponent(initial_time_budget=100.0)
+        comp.current_time_budget = -10.0
+        is_valid, errors = comp.validate("agent_1")
+        assert not is_valid
+        assert "current_time_budget cannot be negative" in errors[0]
+
+    def test_validation_failure_mismatched_active_state(self):
+        """Test validation failure when is_active contradicts the budget."""
+        comp = TimeBudgetComponent(initial_time_budget=100.0)
+        comp.current_time_budget = 0
+        comp.is_active = True  # Should be inactive
+        is_valid, errors = comp.validate("agent_1")
+        assert not is_valid
+        assert "Entity marked active but has no time budget" in errors[0]
+
+    def test_auto_fix_negative_budget(self):
+        """Test that auto_fix corrects a negative budget."""
+        comp = TimeBudgetComponent(initial_time_budget=100.0)
+        comp.current_time_budget = -5.0
+        fixed = comp.auto_fix("agent_1", {})
+        assert fixed
+        assert comp.current_time_budget == 0.0
+        assert not comp.is_active
+
+    def test_to_dict_serialization(self):
+        """Test that the component serializes to a dictionary correctly."""
+        comp = TimeBudgetComponent(initial_time_budget=150.0)
+        comp.current_time_budget = 120.5
+        comp.is_active = True
+        data = comp.to_dict()
+        assert data["initial_time_budget"] == 150.0
+        assert data["current_time_budget"] == 120.5
+        assert data["is_active"]
+
+
+class TestEmotionComponent:
+    """Tests for the EmotionComponent."""
+
+    def test_validation_out_of_bounds(self):
+        """Test that valence and arousal outside their bounds fail validation."""
+        comp_valence = EmotionComponent(valence=1.5)
+        is_valid, errors = comp_valence.validate("agent_1")
+        assert not is_valid
+        assert "Valence out of bounds" in errors[0]
+
+        comp_arousal = EmotionComponent(arousal=-0.5)
+        is_valid, errors = comp_arousal.validate("agent_1")
+        assert not is_valid
+        assert "Arousal out of bounds" in errors[0]
+
+    def test_to_dict_serialization(self):
+        """Test correct serialization."""
+        comp = EmotionComponent(valence=0.5, arousal=0.8, current_emotion_category="happy")
         data = comp.to_dict()
-        assert data == {
-            "confidence_scores": {10: 0.8},
-            "causal_model_confidence": 0.95,
-        }
-
-    @pytest.mark.parametrize(
-        "scores, confidence, is_valid",
-        [
-            ({}, 0.5, True),
-            ({1: 1.0}, 1.0, True),
-            (None, 0.5, False),  # Invalid scores type
-            ({}, "high", False),  # Invalid confidence type
-        ],
-    )
-    def test_validation(self, scores, confidence, is_valid):
-        """Tests the validation logic for various states."""
-        comp = ValidationComponent()
-        comp.reflection_confidence_scores = scores
-        comp.causal_model_confidence = confidence
-        valid, errors = comp.validate("agent_1")
-        assert valid is is_valid
-        if not is_valid:
-            assert len(errors) > 0
-
-    def test_auto_fix(self):
-        """
-        Tests that the auto_fix method correctly resets an invalid state and
-        returns True, indicating a fix was made.
-        """
-        comp = ValidationComponent()
-        # Set an invalid state that auto_fix is designed to correct
-        comp.reflection_confidence_scores = None
-
-        # ACT: Run the auto_fix method
-        # The auto_fix for ValidationComponent doesn't do anything, so we expect False
-        was_fixed = comp.auto_fix("agent_1", {})
-
-        # ASSERT: The auto_fix method for this component doesn't fix this, so it should return False
-        assert was_fixed is False
+        assert data["valence"] == 0.5
+        assert data["arousal"] == 0.8
+        assert data["current_emotion_category"] == "happy"
+
+
+class TestAffectComponent:
+    """Tests for the AffectComponent."""
+
+    def test_validation_nan_dissonance(self):
+        """Test that NaN cognitive dissonance fails validation."""
+        comp = AffectComponent(affective_buffer_maxlen=10)
+        comp.cognitive_dissonance = float("nan")
+        is_valid, errors = comp.validate("agent_1")
+        assert not is_valid
+        assert "Cognitive dissonance is not a finite number" in errors[0]
+
+
+class TestCompetenceComponent:
+    """Tests for the CompetenceComponent."""
+
+    def test_auto_fix_incorrect_type(self):
+        """Test that auto_fix corrects the type of action_counts."""
+        comp = CompetenceComponent()
+        # Intentionally set to a wrong type
+        comp.action_counts = {}
+        fixed = comp.auto_fix("agent_1", {})
+        assert fixed
+        from collections import defaultdict
+
+        assert isinstance(comp.action_counts, defaultdict)
+
+
+class TestBeliefSystemComponent:
+    """Tests for the BeliefSystemComponent."""
+
+    def test_validation_wrong_types(self):
+        """Test that incorrect attribute types fail validation."""
+        comp = BeliefSystemComponent()
+        comp.belief_base = []  # Should be a dict
+        is_valid, errors = comp.validate("agent_1")
+        assert not is_valid
+        assert "'belief_base' attribute must be a dictionary" in errors[0]
+
+
+# You can continue adding simple test classes for other components
+# to quickly boost coverage.
+
+
+def test_goal_component_validation():
+    """Test GoalComponent validation logic."""
+    comp = GoalComponent(embedding_dim=10)
+    comp.current_symbolic_goal = "explore"
+    # Fails because 'explore' is not in the symbolic_goals_data
+    is_valid, errors = comp.validate("agent_1")
+    assert not is_valid
+    assert "not in goal data" in errors[0]
+
+    # Should pass now
+    comp.symbolic_goals_data["explore"] = {}
+    is_valid, errors = comp.validate("agent_1")
+    assert is_valid
+
+
+def test_action_plan_and_outcome_components():
+    """Simple validation and serialization tests for action-related components."""
+    plan = ActionPlanComponent()
+    is_valid, _ = plan.validate("agent_1")
+    assert is_valid
+    assert isinstance(plan.to_dict(), dict)
+
+    outcome = ActionOutcomeComponent()
+    is_valid, _ = outcome.validate("agent_1")
+    assert is_valid
+    assert isinstance(outcome.to_dict(), dict)