test: Add initial test suite for core application logic

Adds unit and integration tests for the project's most critical components, ensuring their correctness and stability.

- A pure unit test was created for the `semantic_chunker` to validate its data grouping logic.
- Mocked tests were implemented for the `rag_pipeline` to test the search filtering and prompt generation logic in isolation from the FAISS index and the external Gemini API.
- Tests have been separated into `test_chunking.py` (fast) and `test_pipeline.py` (slower, mocked) to improve the development testing cycle.

tests/test_chunking.py

@@ -0,0 +1,29 @@
+def test_chunk_by_concept_groups_correctly():
+    """
+    Ensures that items are correctly grouped by (source_document, concept)
+    and that their content is concatenated in the right order.
+    """
+    from src.fot_recommender.semantic_chunker import chunk_by_concept
+
+    # 1. Arrange: Create simple, predictable raw data
+    sample_raw_kb = [
+        {"source_document": "doc_A", "concept": "Mentoring", "absolute_page": 1, "content": "First part."},
+        {"source_document": "doc_B", "concept": "Tutoring", "absolute_page": 10, "content": "Tutoring info."},
+        {"source_document": "doc_A", "concept": "Mentoring", "absolute_page": 2, "content": "Second part."},
+    ]
+
+    # 2. Act: Run the function we're testing
+    final_chunks = chunk_by_concept(sample_raw_kb)
+
+    # 3. Assert: Check the results
+    assert len(final_chunks) == 2  # Should have grouped into 2 concepts
+
+    # Find the 'Mentoring' chunk for detailed checks
+    mentoring_chunk = next(c for c in final_chunks if c["title"] == "Mentoring")
+    
+    assert mentoring_chunk is not None
+    assert mentoring_chunk["source_document"] == "doc_A"
+    assert mentoring_chunk["fot_pages"] == "Pages: 1, 2"
+    assert "First part.\n\nSecond part." in mentoring_chunk["original_content"]
+    assert "Title: Mentoring. Content: First part.\n\nSecond part." in mentoring_chunk["content_for_embedding"]
+    

tests/test_main.py

@@ -1,12 +0,0 @@
-from demo_application.main import main
-import sys
-from io import StringIO
-
-
-def test_main():
-    """Test that main() prints the expected message."""
-    captured_output = StringIO()
-    sys.stdout = captured_output
-    main()
-    sys.stdout = sys.__stdout__
-    assert "Hello from demo application!" in captured_output.getvalue()

tests/test_pipeline.py

@@ -0,0 +1,80 @@
+from unittest.mock import MagicMock, patch
+import numpy as np
+
+def test_search_interventions_filters_by_score():
+    """
+    Ensures the search function correctly filters out results
+    that are below the minimum similarity score threshold.
+    """
+    from src.fot_recommender.rag_pipeline import search_interventions
+
+    # 1. Arrange: Create mock objects and sample data
+    mock_model = MagicMock()
+    mock_index = MagicMock()
+    
+    # Fake knowledge base
+    sample_kb = [{"id": 1, "content": "high score"}, {"id": 2, "content": "low score"}]
+
+    # Configure the mock FAISS index to return specific scores and indices
+    # Let's say it finds two results, one with a high score (0.9) and one low (0.3)
+    mock_index.search.return_value = (
+        np.array([[0.9, 0.3]]),  # scores
+        np.array([[0, 1]])        # indices
+    )
+
+    # 2. Act: Run the search with a minimum score of 0.5
+    results = search_interventions(
+        query="test query",
+        model=mock_model,
+        index=mock_index,
+        knowledge_base=sample_kb,
+        k=2,
+        min_similarity_score=0.5
+    )
+
+    # 3. Assert: Check that only the high-scoring result was returned
+    assert len(results) == 1
+    assert results[0][0]["content"] == "high score" # Check the chunk content
+    assert results[0][1] == 0.9                     # Check the score
+    
+
+def test_generate_recommendation_summary_builds_correct_prompt():
+    """
+    Ensures that the context from retrieved chunks and the student narrative
+    are correctly formatted into the final prompt sent to the LLM.
+    """
+    from src.fot_recommender.rag_pipeline import generate_recommendation_summary
+
+    # 1. Arrange: Create sample inputs
+    sample_chunks = [
+        ({"title": "Tip 1", "original_content": "Do this.", "source_document": "doc_A"}, 0.9),
+    ]
+    student_narrative = "Student is struggling."
+
+    # 2. Act & Assert: Use a patch to intercept the API call
+    # This temporarily replaces genai.GenerativeModel with our mock
+    with patch("src.fot_recommender.rag_pipeline.genai.GenerativeModel") as mock_gen_model:
+        # Create a mock instance that the function will use
+        mock_model_instance = MagicMock()
+        mock_gen_model.return_value = mock_model_instance
+
+        generate_recommendation_summary(
+            retrieved_chunks=sample_chunks,
+            student_narrative=student_narrative,
+            api_key="fake_key",
+            persona="teacher"
+        )
+
+        # 3. Assert: Check what our function tried to do
+        # Was the API call made once?
+        mock_model_instance.generate_content.assert_called_once()
+        
+        # Get the actual prompt that was passed to the LLM
+        actual_prompt = mock_model_instance.generate_content.call_args[0][0]
+
+        # Check if our key pieces of information are in the prompt
+        assert "Student is struggling." in actual_prompt
+        assert "--- Intervention Chunk 1 ---" in actual_prompt
+        assert "Title: Tip 1" in actual_prompt
+        assert "Content: Do this." in actual_prompt
+        assert "(Source Document: doc_A)" in actual_prompt