Add DB/memory unit tests and adjust integration skip

Author: biswasbiplob

feedback_agent/__init__.py

@@ -2,6 +2,9 @@
 
 
 def __getattr__(name: str):
+    if name == "utils":
+        import importlib
+        return importlib.import_module("feedback_agent.utils")
     if name in ("FeedbackSystem", "get_root_agent"):
         from .agent import FeedbackSystem, get_root_agent
         return {"FeedbackSystem": FeedbackSystem, "get_root_agent": get_root_agent}[name]

feedback_agent/database.py

@@ -100,14 +100,23 @@ def log_analysis(self, exam_id: str, weaknesses: Optional[List[str]] = None, top
                 current_weaknesses, current_topics, current_recommendations = row
                 new_weaknesses = json.dumps(weaknesses) if weaknesses is not None else current_weaknesses
                 new_topics = json.dumps(topics) if topics is not None else current_topics
-                new_recommendations = recommendations if recommendations is not None else current_recommendations
+                if recommendations is not None:
+                    new_recommendations = (
+                        json.dumps(recommendations)
+                        if not isinstance(recommendations, str)
+                        else recommendations
+                    )
+                else:
+                    new_recommendations = current_recommendations
 
                 cursor.execute('''
                     UPDATE analysis
                     SET weaknesses = ?, topics = ?, recommendations = ?
                     WHERE exam_id = ?
                 ''', (new_weaknesses, new_topics, new_recommendations, exam_id))
             else:
+                if recommendations is not None and not isinstance(recommendations, str):
+                    recommendations = json.dumps(recommendations)
                 cursor.execute('''
                     INSERT INTO analysis (exam_id, weaknesses, topics, recommendations)
                     VALUES (?, ?, ?, ?)
@@ -223,7 +232,7 @@ def get_analysis(self, exam_id: str) -> Optional[Dict]:
         conn.row_factory = sqlite3.Row
         cursor = conn.cursor()
         cursor.execute('''
-            SELECT weaknesses, recommendations
+            SELECT weaknesses, topics, recommendations
             FROM analysis
             WHERE exam_id = ?
         ''', (exam_id,))
@@ -233,6 +242,7 @@ def get_analysis(self, exam_id: str) -> Optional[Dict]:
         if row:
             return {
                 'weaknesses': json.loads(row['weaknesses']) if row['weaknesses'] else [],
-                'recommendations': row['recommendations']
+                'topics': json.loads(row['topics']) if row['topics'] else [],
+                'recommendations': row['recommendations'],
             }
         return None

tests/test_database.py

@@ -3,6 +3,15 @@
 from feedback_agent.database import StudentDatabase
 
 
+def test_add_student_idempotent(tmp_path):
+    db_path = tmp_path / "students.db"
+    db = StudentDatabase(str(db_path))
+    db.add_student("s1", "Alice")
+    db.add_student("s1", "Alice")
+    students = db.get_all_students()
+    assert len(students) == 1
+
+
 def test_student_lookup_and_history_order(tmp_path):
     db_path = tmp_path / "students.db"
     db = StudentDatabase(str(db_path))

tests/test_database_more.py

@@ -0,0 +1,44 @@
+import uuid
+
+from feedback_agent.database import StudentDatabase
+
+
+def test_get_student_exams_sorted_desc(tmp_path):
+    db_path = tmp_path / "students.db"
+    db = StudentDatabase(str(db_path))
+    student_id = str(uuid.uuid4())
+    db.add_student(student_id, "Sort Test")
+
+    exam_id_1 = str(uuid.uuid4())
+    exam_id_2 = str(uuid.uuid4())
+
+    db.log_exam(exam_id_1, student_id, "Math", 8, 10)
+    db.log_exam(exam_id_2, student_id, "Science", 9, 10)
+
+    exams = db.get_student_exams(student_id)
+    assert len(exams) == 2
+    assert exams[0]["exam_id"] == exam_id_2
+    assert exams[1]["exam_id"] == exam_id_1
+
+
+def test_get_analysis_topics_and_recommendations(tmp_path):
+    db_path = tmp_path / "students.db"
+    db = StudentDatabase(str(db_path))
+    student_id = str(uuid.uuid4())
+    db.add_student(student_id, "Analysis Test")
+
+    exam_id = str(uuid.uuid4())
+    db.log_exam(exam_id, student_id, "History", 5, 10)
+
+    db.log_analysis(
+        exam_id,
+        weaknesses=[{"topic": "Revolutions"}],
+        topics=["Revolutions"],
+        recommendations='{"plan": "review"}',
+    )
+
+    analysis = db.get_analysis(exam_id)
+    assert analysis is not None
+    assert analysis["weaknesses"][0]["topic"] == "Revolutions"
+    assert analysis["topics"] == ["Revolutions"]
+    assert analysis["recommendations"] == '{"plan": "review"}'

tests/test_integration.py

@@ -1,31 +1,18 @@
-import pytest
+import asyncio
+from unittest.mock import patch
 
-pytest.importorskip("google.adk")
+from feedback_agent.database import StudentDatabase
 
-import os
-from feedback_agent.agent import FeedbackSystem
 
-@pytest.fixture
-def system():
-    # Use a temporary db for testing
-    db_path = "data/test_students.db"
-    if os.path.exists(db_path):
-        os.remove(db_path)
-    
-    sys = FeedbackSystem(db_path=db_path)
-    yield sys
-    
-    if os.path.exists(db_path):
-        os.remove(db_path)
+def test_full_flow_mocked(tmp_path):
+    import pytest
+    pytest.importorskip("google.adk")
+    db_path = tmp_path / "students.db"
+    _ = StudentDatabase(str(db_path))
 
+    def mock_run_agent(agent, prompt, image_path=None, image_bytes=None, session_state=None):
+        import json
 
-
-def test_full_flow_mocked(system):
-    from unittest.mock import patch
-    import json
-
-    # Mock responses for different agents
-    def mock_run_agent(agent, prompt):
         if "grading_agent" in agent.name:
             return json.dumps({
                 "total_score": 8,
@@ -52,43 +39,73 @@ def mock_run_agent(agent, prompt):
             })
         elif "analysis_agent" in agent.name:
             return json.dumps({
-                "weaknesses": ["Arithmetic"],
+                "topics": ["Arithmetic"],
+                "weaknesses": [
+                    {"topic": "Arithmetic", "description": "Struggled with subtraction", "severity": "medium"}
+                ],
                 "summary": "Weak in math."
             })
-        elif "recommendation_agent" in agent.name:
+        elif "study_materials_agent" in agent.name:
+            return json.dumps({
+                "study_materials": [
+                    {"topic": "Arithmetic", "resources": [{"type": "textbook", "title": "Math 101", "description": "Basics", "difficulty": "beginner"}]}
+                ]
+            })
+        elif "practice_problems_agent" in agent.name:
+            return json.dumps({
+                "practice_problems": [
+                    {"topic": "Arithmetic", "problems": [{"difficulty": "easy", "problem": "2+2", "hint": "Add", "learning_goal": "Addition"}]}
+                ]
+            })
+        elif "learning_strategy_agent" in agent.name:
+            return json.dumps({
+                "learning_strategy": {
+                    "study_schedule": {"weekly_hours": 2, "sessions_per_week": 2, "session_duration": "30m"},
+                    "learning_techniques": [{"technique": "Flashcards", "when_to_use": "Daily", "expected_benefit": "Recall"}],
+                    "milestones": [{"timeline": "1 week", "goal": "Basics", "success_criteria": "80% correct"}]
+                }
+            })
+        elif "recommendation_synthesizer" in agent.name:
             return json.dumps({
                 "learning_objectives": [
                     {
-                        "topic": "Arithmetic",
                         "objective": "Learn addition",
-                        "resources": ["Math book"]
+                        "resources": ["Math 101"],
+                        "practice_activities": ["2+2"],
+                        "estimated_time": "1 week",
+                        "priority": "high"
                     }
                 ],
-                "encouragement": "Keep practicing!"
+                "weekly_plan": {
+                    "total_hours": 2,
+                    "activities": [{"day": "Mon", "activity": "Practice", "duration": "30m", "resources_needed": ["Math 101"]}]
+                },
+                "encouragement": "Keep practicing!",
+                "success_metrics": ["80% on quizzes"]
             })
         return "{}"
 
-    with patch('feedback_agent.utils.run_agent', side_effect=mock_run_agent):
-        # 1. Register Student
+    with patch("feedback_agent.agent.run_agent", side_effect=mock_run_agent, create=True):
+        from feedback_agent.agent import FeedbackSystem
+
+        system = FeedbackSystem(
+            db_path=str(db_path),
+            use_memory_sessions=True,
+            enable_metrics=False,
+            enable_logging_plugin=False,
+        )
+
         student_id = system.register_student("Alice")
         assert student_id is not None
 
-        # 2. Process Exam
-        exam_content = "..."
-        answer_key = "..."
-        
-        result = system.process_exam(student_id, "General Knowledge", exam_content, answer_key)
-        
-        # Verify Grading
-        assert result['grading']['total_score'] == 8
-        
-        # Verify Analysis
-        assert "Arithmetic" in result['analysis']['weaknesses']
-        
-        # Verify Recommendations
-        assert len(result['recommendations']['learning_objectives']) > 0
+        result = asyncio.run(
+            system.process_exam(student_id, "...", "...", "General Knowledge")
+        )
+
+        assert result["total_score"] == 8
+        assert "Arithmetic" in result["weaknesses"][0]["topic"]
+        assert result["recommendations"]
 
-        # Verify DB Persistence
         history = system.db.get_student_history(student_id)
         assert len(history) == 1
-        assert history[0]['subject'] == "General Knowledge"
+        assert history[0]["subject"] == "General Knowledge"