🧪 Add tests for feature

Author: Jasonxia007

test/backend/app/test_vectordatabase_app.py

@@ -673,6 +673,53 @@ async def test_get_index_files_permission_exception(vdb_core_mock):
         mock_list_files.assert_called_once()
 
 
+@pytest.mark.asyncio
+async def test_get_index_chunks_success(vdb_core_mock):
+    """
+    Test retrieving index chunks successfully.
+    Verifies that the endpoint forwards query params and returns the service payload.
+    """
+    with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
+            patch("backend.apps.vectordatabase_app.ElasticSearchService.get_index_chunks") as mock_get_chunks:
+
+        index_name = "test_index"
+        expected_response = {
+            "status": "success",
+            "message": "ok",
+            "chunks": [{"id": "1"}],
+            "total": 1
+        }
+        mock_get_chunks.return_value = expected_response
+
+        response = client.post(
+            f"/indices/{index_name}/chunks",
+            params={"batch_size": 500}
+        )
+
+        assert response.status_code == 200
+        assert response.json() == expected_response
+        mock_get_chunks.assert_called_once_with(index_name, 500, ANY)
+
+
+@pytest.mark.asyncio
+async def test_get_index_chunks_error(vdb_core_mock):
+    """
+    Test retrieving index chunks with service error.
+    Ensures the endpoint maps the exception to HTTP 500.
+    """
+    with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
+            patch("backend.apps.vectordatabase_app.ElasticSearchService.get_index_chunks") as mock_get_chunks:
+
+        index_name = "test_index"
+        mock_get_chunks.side_effect = Exception("Chunk failure")
+
+        response = client.post(f"/indices/{index_name}/chunks")
+
+        assert response.status_code == 500
+        assert response.json() == {"detail": "Error getting chunks: Chunk failure"}
+        mock_get_chunks.assert_called_once_with(index_name, 1000, ANY)
+
+
 @pytest.mark.asyncio
 async def test_health_check_success(vdb_core_mock):
     """

test/backend/services/test_vectordatabase_service.py

@@ -1284,6 +1284,57 @@ def test_get_summary_not_found(self, mock_get_record):
 
         self.assertIn("Unable to get summary", str(context.exception))
 
+    def test_get_index_chunks_filters_fields(self):
+        """
+        Test chunk retrieval filters unsupported fields and reports totals.
+        """
+        self.mock_vdb_core.get_index_chunks.return_value = [
+            {"id": "1", "content": "A", "path_or_url": "/a", "extra": "ignore"},
+            {"content": "B", "create_time": "2024-01-01T00:00:00"}
+        ]
+
+        result = ElasticSearchService.get_index_chunks(
+            index_name="kb-index",
+            batch_size=500,
+            vdb_core=self.mock_vdb_core
+        )
+
+        self.assertEqual(result["status"], "success")
+        self.assertEqual(result["total"], 2)
+        self.assertEqual(result["chunks"][0], {"id": "1", "content": "A", "path_or_url": "/a"})
+        self.assertEqual(result["chunks"][1], {"content": "B", "create_time": "2024-01-01T00:00:00"})
+        self.mock_vdb_core.get_index_chunks.assert_called_once_with("kb-index", 500)
+
+    def test_get_index_chunks_keeps_non_dict_entries(self):
+        """
+        Test chunk retrieval keeps non-dict entries unchanged.
+        """
+        self.mock_vdb_core.get_index_chunks.return_value = ["raw_chunk"]
+
+        result = ElasticSearchService.get_index_chunks(
+            index_name="kb-index",
+            batch_size=10,
+            vdb_core=self.mock_vdb_core
+        )
+
+        self.assertEqual(result["chunks"], ["raw_chunk"])
+        self.assertEqual(result["total"], 1)
+
+    def test_get_index_chunks_error(self):
+        """
+        Test chunk retrieval error handling.
+        """
+        self.mock_vdb_core.get_index_chunks.side_effect = Exception("boom")
+
+        with self.assertRaises(Exception) as exc:
+            ElasticSearchService.get_index_chunks(
+                index_name="kb-index",
+                batch_size=10,
+                vdb_core=self.mock_vdb_core
+            )
+
+        self.assertIn("Error retrieving chunks from index kb-index: boom", str(exc.exception))
+
     @patch('backend.services.vectordatabase_service.get_knowledge_info_by_tenant_id')
     @patch('fastapi.Response')
     def test_list_indices_success_status_200(self, mock_response, mock_get_knowledge):

test/sdk/vector_database/test_elasticsearch_core.py

@@ -2,6 +2,7 @@
 from unittest.mock import MagicMock, patch
 import time
 from typing import List, Dict, Any
+from elasticsearch import exceptions
 
 # Import the class under test
 from sdk.nexent.vector_database.elasticsearch_core import ElasticSearchCore
@@ -445,8 +446,6 @@ def test_delete_index_success(elasticsearch_core_instance):
 
 def test_delete_index_not_found(elasticsearch_core_instance):
     """Test deleting an index that doesn't exist."""
-    from elasticsearch import exceptions
-
     with patch.object(elasticsearch_core_instance.client.indices, 'delete') as mock_delete:
         mock_delete.side_effect = exceptions.NotFoundError(
             "Index not found", {}, {})
@@ -574,6 +573,69 @@ def test_delete_documents_success(elasticsearch_core_instance):
         mock_delete.assert_called_once()
 
 
+def test_get_index_chunks_success(elasticsearch_core_instance):
+    """Test fetching chunks via scroll API."""
+    elasticsearch_core_instance.client = MagicMock()
+    elasticsearch_core_instance.client.search.return_value = {
+        "_scroll_id": "scroll123",
+        "hits": {
+            "hits": [
+                {"_id": "doc-1", "_source": {"id": "chunk-1", "content": "A"}},
+                {"_id": "doc-2", "_source": {"content": "B"}}
+            ]
+        }
+    }
+    elasticsearch_core_instance.client.scroll.return_value = {
+        "_scroll_id": "scroll123",
+        "hits": {"hits": []}
+    }
+
+    chunks = elasticsearch_core_instance.get_index_chunks("kb-index", batch_size=2)
+
+    assert chunks == [
+        {"id": "chunk-1", "content": "A"},
+        {"content": "B", "id": "doc-2"}
+    ]
+    elasticsearch_core_instance.client.search.assert_called_once()
+    elasticsearch_core_instance.client.scroll.assert_called_once_with(scroll_id="scroll123", scroll="2m")
+    elasticsearch_core_instance.client.clear_scroll.assert_called_once_with(scroll_id="scroll123")
+
+
+def test_get_index_chunks_not_found(elasticsearch_core_instance):
+    """Test fetching chunks when index does not exist."""
+    elasticsearch_core_instance.client = MagicMock()
+    elasticsearch_core_instance.client.search.side_effect = exceptions.NotFoundError(404, "not found", {})
+
+    chunks = elasticsearch_core_instance.get_index_chunks("missing-index")
+
+    assert chunks == []
+    elasticsearch_core_instance.client.clear_scroll.assert_not_called()
+
+
+def test_get_index_chunks_cleanup_failure(elasticsearch_core_instance):
+    """Test cleanup warning path when clear_scroll raises."""
+    elasticsearch_core_instance.client = MagicMock()
+    elasticsearch_core_instance.client.search.return_value = {
+        "_scroll_id": "scroll123",
+        "hits": {
+            "hits": [
+                {"_id": "doc-1", "_source": {"content": "A"}}
+            ]
+        }
+    }
+    elasticsearch_core_instance.client.scroll.return_value = {
+        "_scroll_id": "scroll123",
+        "hits": {"hits": []}
+    }
+    elasticsearch_core_instance.client.clear_scroll.side_effect = Exception("cleanup error")
+
+    chunks = elasticsearch_core_instance.get_index_chunks("kb-index")
+
+    assert len(chunks) == 1
+    assert chunks[0]["id"] == "doc-1"
+    elasticsearch_core_instance.client.clear_scroll.assert_called_once_with(scroll_id="scroll123")
+
+
 # ----------------------------------------------------------------------------
 # Tests for search operations
 # ----------------------------------------------------------------------------

test/sdk/vector_database/test_elasticsearch_core_coverage.py

@@ -258,6 +258,37 @@ def test_delete_documents_exception(self, vdb_core):
         assert result == 0
         vdb_core.client.delete_by_query.assert_called_once()
 
+    def test_get_index_chunks_not_found(self, vdb_core):
+        """Ensure get_index_chunks handles missing index gracefully."""
+        vdb_core.client = MagicMock()
+        vdb_core.client.search.side_effect = exceptions.NotFoundError(
+            404, "missing", {})
+
+        result = vdb_core.get_index_chunks("missing-index")
+
+        assert result == []
+        vdb_core.client.clear_scroll.assert_not_called()
+
+    def test_get_index_chunks_cleanup_warning(self, vdb_core):
+        """Ensure clear_scroll errors are swallowed."""
+        vdb_core.client = MagicMock()
+        vdb_core.client.search.return_value = {
+            "_scroll_id": "scroll123",
+            "hits": {"hits": [{"_id": "doc-1", "_source": {"content": "A"}}]}
+        }
+        vdb_core.client.scroll.return_value = {
+            "_scroll_id": "scroll123",
+            "hits": {"hits": []}
+        }
+        vdb_core.client.clear_scroll.side_effect = Exception("cleanup-failed")
+
+        result = vdb_core.get_index_chunks("kb-index", batch_size=1)
+
+        assert len(result) == 1
+        assert result[0]["id"] == "doc-1"
+        vdb_core.client.clear_scroll.assert_called_once_with(
+            scroll_id="scroll123")
+
     def test_create_index_request_error_existing(self, vdb_core):
         """Ensure RequestError with resource already exists still succeeds."""
         vdb_core.client = MagicMock()