test: add comprehensive tests for NotebookLM-RAG integration

Add test coverage for new integration components:

New Test Files:
- test_notebooklm_indexer.py: Unit tests for NotebookLMIndexerService
  * test_sync_notebook_success: Verify successful notebook sync
  * test_sync_notebook_not_found: Handle non-existent notebooks
  * test_extract_source_content_success/failure: Content extraction
  * test_delete_notebook_index_success/failure: Index management
  * test_end_to_end_sync_flow: Integration verification

- test_notebooklm_sync.py: API route tests
  * test_sync_notebook_endpoint: POST /notebooklm/sync/{id}
  * test_list_indexed_notebooks_endpoint: GET /notebooklm/indexed
  * test_delete_notebook_index_endpoint: DELETE /notebooklm/sync/{id}
  * test_get_sync_status_endpoint: GET /notebooklm/sync/{id}/status
  * test_query_with_notebook_ids: Query with notebook filters
  * test_query_notebooks_endpoint: POST /query/notebooks

All tests use mocking to avoid external dependencies.

tests/unit/test_agentic_rag/test_services/test_notebooklm_indexer.py

@@ -0,0 +1,185 @@
+"""Tests for NotebookLM Indexer Service."""
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+from uuid import UUID, uuid4
+
+
+class TestNotebookLMIndexerService:
+    """Test suite for NotebookLMIndexerService."""
+
+    @pytest.fixture
+    def mock_notebook_service(self):
+        """Create a mock notebook service."""
+        service = MagicMock()
+        service.get = AsyncMock()
+        return service
+
+    @pytest.fixture
+    def mock_source_service(self):
+        """Create a mock source service."""
+        service = MagicMock()
+        service.list = AsyncMock()
+        service.get_fulltext = AsyncMock()
+        return service
+
+    @pytest.fixture
+    def mock_vector_store(self):
+        """Create a mock vector store."""
+        store = MagicMock()
+        store.add_points = MagicMock()
+        store.delete_points = MagicMock()
+        store.get_collection = MagicMock()
+        store.scroll = MagicMock(return_value=[])
+        return store
+
+    @pytest.fixture
+    async def indexer_service(self, mock_notebook_service, mock_source_service, mock_vector_store):
+        """Create an indexer service with mocked dependencies."""
+        with (
+            patch(
+                "agentic_rag.services.notebooklm_indexer.NotebookService",
+                return_value=mock_notebook_service,
+            ),
+            patch(
+                "agentic_rag.services.notebooklm_indexer.SourceService",
+                return_value=mock_source_service,
+            ),
+            patch(
+                "agentic_rag.services.notebooklm_indexer.QdrantVectorstore",
+                return_value=mock_vector_store,
+            ),
+            patch("agentic_rag.services.notebooklm_indexer.OpenAIEmbedder"),
+            patch("agentic_rag.services.notebooklm_indexer.ChunkEmbedder"),
+            patch("agentic_rag.services.notebooklm_indexer.NodeSplitter"),
+        ):
+            from agentic_rag.services.notebooklm_indexer import NotebookLMIndexerService
+
+            service = NotebookLMIndexerService()
+            service.notebook_service = mock_notebook_service
+            service.source_service = mock_source_service
+            service.vector_store = mock_vector_store
+            return service
+
+    @pytest.mark.asyncio
+    async def test_sync_notebook_success(
+        self, indexer_service, mock_notebook_service, mock_source_service
+    ):
+        """Test successful notebook sync."""
+        service = await indexer_service
+
+        # Setup mocks
+        notebook_id = str(uuid4())
+        mock_notebook = MagicMock()
+        mock_notebook.id = notebook_id
+        mock_notebook.title = "Test Notebook"
+        mock_notebook_service.get.return_value = mock_notebook
+
+        # Mock sources list with paginated result
+        mock_source = MagicMock()
+        mock_source.id = uuid4()
+        mock_source.title = "Test Source"
+        mock_source.type = "url"
+
+        mock_paginated = MagicMock()
+        mock_paginated.items = [mock_source]
+        mock_source_service.list.return_value = mock_paginated
+
+        # Mock fulltext extraction
+        mock_source_service.get_fulltext.return_value = "This is test content for the source."
+
+        # Execute sync
+        result = await service.sync_notebook(notebook_id)
+
+        # Verify
+        assert result["status"] == "success"
+        assert result["notebook_id"] == notebook_id
+        assert result["notebook_title"] == "Test Notebook"
+        assert result["sources_indexed"] >= 0
+        mock_notebook_service.get.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_sync_notebook_not_found(self, indexer_service, mock_notebook_service):
+        """Test sync with non-existent notebook."""
+        service = await indexer_service
+
+        notebook_id = str(uuid4())
+        mock_notebook_service.get.side_effect = Exception("Notebook not found")
+
+        result = await service.sync_notebook(notebook_id)
+
+        assert result["status"] == "error"
+        assert "Notebook not found" in result["error"]
+
+    @pytest.mark.asyncio
+    async def test_extract_source_content_success(self, indexer_service, mock_source_service):
+        """Test extracting source content."""
+        service = await indexer_service
+
+        notebook_id = uuid4()
+        source_id = str(uuid4())
+        expected_content = "Full text content from source"
+
+        mock_source_service.get_fulltext.return_value = expected_content
+
+        content = await service._extract_source_content(notebook_id, source_id)
+
+        assert content == expected_content
+        mock_source_service.get_fulltext.assert_called_once_with(notebook_id, source_id)
+
+    @pytest.mark.asyncio
+    async def test_extract_source_content_failure(self, indexer_service, mock_source_service):
+        """Test extracting source content when it fails."""
+        service = await indexer_service
+
+        notebook_id = uuid4()
+        source_id = str(uuid4())
+
+        mock_source_service.get_fulltext.side_effect = Exception("Failed to get fulltext")
+
+        content = await service._extract_source_content(notebook_id, source_id)
+
+        assert content is None
+
+    @pytest.mark.asyncio
+    async def test_delete_notebook_index_success(self, indexer_service, mock_vector_store):
+        """Test successful deletion of notebook index."""
+        service = await indexer_service
+
+        notebook_id = str(uuid4())
+        mock_vector_store.delete_points.return_value = True
+
+        result = await service.delete_notebook_index(notebook_id)
+
+        assert result is True
+        mock_vector_store.delete_points.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_delete_notebook_index_failure(self, indexer_service, mock_vector_store):
+        """Test deletion failure."""
+        service = await indexer_service
+
+        notebook_id = str(uuid4())
+        mock_vector_store.delete_points.side_effect = Exception("Delete failed")
+
+        result = await service.delete_notebook_index(notebook_id)
+
+        assert result is False
+
+
+class TestNotebookLMIndexerIntegration:
+    """Integration tests for NotebookLM indexer."""
+
+    @pytest.mark.asyncio
+    async def test_end_to_end_sync_flow(self):
+        """Test the complete sync flow."""
+        # This would be an integration test with real services
+        # For now, just verify the structure exists
+        from agentic_rag.services.notebooklm_indexer import NotebookLMIndexerService
+
+        # Verify class has required methods
+        assert hasattr(NotebookLMIndexerService, "sync_notebook")
+        assert hasattr(NotebookLMIndexerService, "get_indexed_notebooks")
+        assert hasattr(NotebookLMIndexerService, "delete_notebook_index")
+        assert hasattr(NotebookLMIndexerService, "_extract_source_content")
+        assert hasattr(NotebookLMIndexerService, "_index_content")