🧪 Add test files for knowledgebase

Author: Jasonxia007

…knowledge_name_to_knowledge_record_t.sql …knowledge_name_to_knowledge_record_t.sqldocker/sql/1204_add_knowledge_name_to_knowledge_record_t.sql renamed to docker/sql/v1.7.7.1_1204_add_knowledge_name_to_knowledge_record_t.sql docker/sql/1204_add_knowledge_name_to_knowledge_record_t.sql renamed to docker/sql/v1.7.7.1_1204_add_knowledge_name_to_knowledge_record_t.sql

@@ -152,7 +152,7 @@ async def test_create_new_index_success(vdb_core_mock, auth_data):
     # Setup mocks
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id", return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
-            patch("backend.apps.vectordatabase_app.ElasticSearchService.create_index") as mock_create:
+            patch("backend.apps.vectordatabase_app.ElasticSearchService.create_knowledge_base") as mock_create:
 
         expected_response = {"status": "success",
                              "index_name": auth_data["index_name"]}
@@ -165,7 +165,13 @@ async def test_create_new_index_success(vdb_core_mock, auth_data):
         # Verify
         assert response.status_code == 200
         assert response.json() == expected_response
+        # vdb_core is constructed inside router; accept ANY for instance
         mock_create.assert_called_once()
+        called_args = mock_create.call_args[0]
+        assert called_args[0] == auth_data["index_name"]
+        assert called_args[1] == 768
+        assert called_args[3] == auth_data["user_id"]
+        assert called_args[4] == auth_data["tenant_id"]
 
 
 @pytest.mark.asyncio
@@ -177,7 +183,7 @@ async def test_create_new_index_error(vdb_core_mock, auth_data):
     # Setup mocks
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id", return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
-            patch("backend.apps.vectordatabase_app.ElasticSearchService.create_index") as mock_create:
+            patch("backend.apps.vectordatabase_app.ElasticSearchService.create_knowledge_base") as mock_create:
 
         mock_create.side_effect = Exception("Test error")
 
@@ -702,10 +708,11 @@ 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.
     """
+    index_name = "test_index"
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
+            patch("backend.apps.vectordatabase_app.get_index_name_by_knowledge_name", return_value="resolved_index"), \
             patch("backend.apps.vectordatabase_app.ElasticSearchService.get_index_chunks") as mock_get_chunks:
 
-        index_name = "test_index"
         expected_response = {
             "status": "success",
             "message": "ok",
@@ -724,7 +731,7 @@ async def test_get_index_chunks_success(vdb_core_mock):
         assert response.status_code == 200
         assert response.json() == expected_response
         mock_get_chunks.assert_called_once_with(
-            index_name=index_name,
+            index_name="resolved_index",
             page=2,
             page_size=50,
             path_or_url="/foo",
@@ -738,18 +745,19 @@ 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.
     """
+    index_name = "test_index"
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
+            patch("backend.apps.vectordatabase_app.get_index_name_by_knowledge_name", return_value="resolved_index"), \
             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=index_name,
+            index_name="resolved_index",
             page=None,
             page_size=None,
             path_or_url=None,
@@ -765,6 +773,7 @@ async def test_create_chunk_success(vdb_core_mock, auth_data):
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id",
                   return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
+            patch("backend.apps.vectordatabase_app.get_index_name_by_knowledge_name", return_value=auth_data["index_name"]), \
             patch("backend.apps.vectordatabase_app.ElasticSearchService.create_chunk") as mock_create:
 
         expected_response = {"status": "success", "chunk_id": "chunk-1"}
@@ -794,6 +803,7 @@ async def test_create_chunk_error(vdb_core_mock, auth_data):
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id",
                   return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
+            patch("backend.apps.vectordatabase_app.get_index_name_by_knowledge_name", return_value=auth_data["index_name"]), \
             patch("backend.apps.vectordatabase_app.ElasticSearchService.create_chunk") as mock_create:
 
         mock_create.side_effect = Exception("Create failed")
@@ -822,6 +832,7 @@ async def test_update_chunk_success(vdb_core_mock, auth_data):
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id",
                   return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
+            patch("backend.apps.vectordatabase_app.get_index_name_by_knowledge_name", return_value=auth_data["index_name"]), \
             patch("backend.apps.vectordatabase_app.ElasticSearchService.update_chunk") as mock_update:
 
         expected_response = {"status": "success", "chunk_id": "chunk-1"}
@@ -850,6 +861,7 @@ async def test_update_chunk_value_error(vdb_core_mock, auth_data):
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id",
                   return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
+            patch("backend.apps.vectordatabase_app.get_index_name_by_knowledge_name", return_value=auth_data["index_name"]), \
             patch("backend.apps.vectordatabase_app.ElasticSearchService.update_chunk") as mock_update:
 
         mock_update.side_effect = ValueError("Invalid update payload")
@@ -864,7 +876,8 @@ async def test_update_chunk_value_error(vdb_core_mock, auth_data):
             headers=auth_data["auth_header"],
         )
 
-        assert response.status_code == 400
+        # ValueError is mapped to NOT_FOUND in app layer
+        assert response.status_code == 404
         assert response.json() == {"detail": "Invalid update payload"}
         mock_update.assert_called_once()
 
@@ -877,6 +890,7 @@ async def test_update_chunk_exception(vdb_core_mock, auth_data):
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id",
                   return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
+            patch("backend.apps.vectordatabase_app.get_index_name_by_knowledge_name", return_value=auth_data["index_name"]), \
             patch("backend.apps.vectordatabase_app.ElasticSearchService.update_chunk") as mock_update:
 
         mock_update.side_effect = Exception("Update failed")
@@ -904,6 +918,7 @@ async def test_delete_chunk_success(vdb_core_mock, auth_data):
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id",
                   return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
+            patch("backend.apps.vectordatabase_app.get_index_name_by_knowledge_name", return_value=auth_data["index_name"]), \
             patch("backend.apps.vectordatabase_app.ElasticSearchService.delete_chunk") as mock_delete:
 
         expected_response = {"status": "success", "chunk_id": "chunk-1"}
@@ -927,6 +942,7 @@ async def test_delete_chunk_not_found(vdb_core_mock, auth_data):
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id",
                   return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
+            patch("backend.apps.vectordatabase_app.get_index_name_by_knowledge_name", return_value=auth_data["index_name"]), \
             patch("backend.apps.vectordatabase_app.ElasticSearchService.delete_chunk") as mock_delete:
 
         mock_delete.side_effect = ValueError("Chunk not found")
@@ -949,6 +965,7 @@ async def test_delete_chunk_exception(vdb_core_mock, auth_data):
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id",
                   return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
+            patch("backend.apps.vectordatabase_app.get_index_name_by_knowledge_name", return_value=auth_data["index_name"]), \
             patch("backend.apps.vectordatabase_app.ElasticSearchService.delete_chunk") as mock_delete:
 
         mock_delete.side_effect = Exception("Delete failed")

test/backend/app/test_vectordatabase_app.py

@@ -115,6 +115,7 @@ def decorator(func):
         # New defaults required by ray_actors import
         const_mod.DEFAULT_EXPECTED_CHUNK_SIZE = 1024
         const_mod.DEFAULT_MAXIMUM_CHUNK_SIZE = 1536
+        const_mod.ROOT_DIR = "/mock/root"
         sys.modules["consts.const"] = const_mod
     # Minimal stub for consts.model used by utils.file_management_utils
     if "consts.model" not in sys.modules:
@@ -328,7 +329,7 @@ def failing_init(**kwargs):
     # Verify that the exception is re-raised
     with pytest.raises(RuntimeError) as exc_info:
         tasks.init_ray_in_worker()
-    assert exc_info.value == init_exception
+    assert "Failed to initialize Ray for Celery worker" in str(exc_info.value)
 
 
 def test_run_async_no_running_loop(monkeypatch):
@@ -554,6 +555,37 @@ def get(self, k):
     json.loads(str(ei.value))
 
 
+def test_forward_returns_when_task_cancelled(monkeypatch):
+    """forward should exit early when cancellation flag is set"""
+    tasks, _ = import_tasks_with_fake_ray(monkeypatch)
+    monkeypatch.setattr(tasks, "ELASTICSEARCH_SERVICE", "http://api")
+
+    class FakeRedisService:
+        def __init__(self):
+            self.calls = 0
+
+        def is_task_cancelled(self, task_id):
+            self.calls += 1
+            return True
+
+    fake_service = FakeRedisService()
+    monkeypatch.setattr(tasks, "get_redis_service", lambda: fake_service)
+
+    self = FakeSelf("cancel-1")
+    result = tasks.forward(
+        self,
+        processed_data={"chunks": [{"content": "keep", "metadata": {}}]},
+        index_name="idx",
+        source="/a.txt",
+    )
+
+    assert result["chunks_stored"] == 0
+    assert "cancelled" in result["es_result"]["message"].lower()
+    assert fake_service.calls == 1
+    # No state updates should occur because we returned early
+    assert self.states == []
+
+
 def test_forward_redis_client_from_url_failure(monkeypatch):
     tasks, _ = import_tasks_with_fake_ray(monkeypatch)
     monkeypatch.setattr(tasks, "ELASTICSEARCH_SERVICE", "http://api")
@@ -1082,6 +1114,48 @@ def __init__(self):
     assert success_state.get("meta", {}).get("processing_speed_mb_s") == 0
 
 
+def test_process_no_chunks_saves_error(monkeypatch, tmp_path):
+    """process should save error info when no chunks are produced"""
+    tasks, fake_ray = import_tasks_with_fake_ray(monkeypatch, initialized=True)
+
+    class FakeActor:
+        def __init__(self):
+            self.process_file = types.SimpleNamespace(
+                remote=lambda *a, **k: "ref-empty")
+            self.store_chunks_in_redis = types.SimpleNamespace(
+                remote=lambda *a, **k: None)
+
+    monkeypatch.setattr(tasks, "get_ray_actor", lambda: FakeActor())
+    fake_ray.get_returns = []  # no chunks returned from ray.get
+
+    saved_reason = {}
+    monkeypatch.setattr(
+        tasks,
+        "save_error_to_redis",
+        lambda task_id, reason, start_time: saved_reason.setdefault(
+            "reason", reason),
+    )
+
+    f = tmp_path / "empty_file.txt"
+    f.write_text("data")
+
+    self = FakeSelf("no-chunks")
+    with pytest.raises(Exception) as exc_info:
+        tasks.process(
+            self,
+            source=str(f),
+            source_type="local",
+            chunking_strategy="basic",
+            index_name="idx",
+            original_filename="empty_file.txt",
+        )
+
+    assert '"error_code": "no_valid_chunks"' in saved_reason.get("reason", "")
+    assert any(state.get("meta", {}).get("stage") ==
+               "text_extraction_failed" for state in self.states)
+    json.loads(str(exc_info.value))
+
+
 def test_process_url_source_with_many_chunks(monkeypatch):
     """Test processing URL source that generates many chunks"""
     tasks, fake_ray = import_tasks_with_fake_ray(monkeypatch, initialized=True)

test/backend/data_process/test_tasks.py

@@ -2,6 +2,7 @@
 import types
 import importlib
 import pytest
+import os
 
 
 class FakeRay:
@@ -44,6 +45,7 @@ def setup_mocks_for_worker(mocker, initialized=False):
         const_mod.FORWARD_REDIS_RETRY_MAX = 1
         const_mod.DISABLE_RAY_DASHBOARD = False
         const_mod.DATA_PROCESS_SERVICE = "http://data-process"
+        const_mod.ROOT_DIR = "/mock/root"
         sys.modules["consts.const"] = const_mod
 
     # Stub celery module and submodules (required by tasks.py imported via __init__.py)
@@ -483,6 +485,23 @@ def init_ray_for_worker(cls, address):
     assert worker_module.worker_state['initialized'] is True
 
 
+def test_setup_worker_environment_sets_ray_preallocate_env(mocker):
+    """Ensure setup_worker_environment sets RAY_preallocate_plasma env var"""
+    worker_module, _ = setup_mocks_for_worker(mocker, initialized=False)
+
+    # Force init success to avoid fallback path exceptions
+    class FakeRayConfig:
+        @classmethod
+        def init_ray_for_worker(cls, address):
+            return True
+
+    mocker.patch.object(worker_module, "RayConfig", FakeRayConfig)
+
+    worker_module.setup_worker_environment()
+
+    assert os.environ.get("RAY_preallocate_plasma") == str(worker_module.RAY_preallocate_plasma).lower()
+
+
 def test_setup_worker_environment_ray_init_fallback(mocker):
     """Test setup_worker_environment with Ray init fallback"""
     worker_module, fake_ray = setup_mocks_for_worker(mocker, initialized=False)

test/backend/data_process/test_worker.py

@@ -71,6 +71,7 @@ class MockKnowledgeRecord:
     def __init__(self, **kwargs):
         self.knowledge_id = kwargs.get('knowledge_id', 1)
         self.index_name = kwargs.get('index_name', 'test_index')
+        self.knowledge_name = kwargs.get('knowledge_name', 'test_index')
         self.knowledge_describe = kwargs.get('knowledge_describe', 'test description')
         self.created_by = kwargs.get('created_by', 'test_user')
         self.updated_by = kwargs.get('updated_by', 'test_user')
@@ -83,6 +84,7 @@ def __init__(self, **kwargs):
     # Mock SQLAlchemy column attributes
     knowledge_id = MagicMock(name="knowledge_id_column")
     index_name = MagicMock(name="index_name_column")
+    knowledge_name = MagicMock(name="knowledge_name_column")
     knowledge_describe = MagicMock(name="knowledge_describe_column")
     created_by = MagicMock(name="created_by_column")
     updated_by = MagicMock(name="updated_by_column")
@@ -125,8 +127,9 @@ def test_create_knowledge_record_success(monkeypatch, mock_session):
     session, _ = mock_session
 
     # Create mock knowledge record
-    mock_record = MockKnowledgeRecord()
+    mock_record = MockKnowledgeRecord(knowledge_name="test_knowledge")
     mock_record.knowledge_id = 123
+    mock_record.index_name = "test_knowledge"
 
     # Mock database session context
     mock_ctx = MagicMock()
@@ -140,16 +143,21 @@ def test_create_knowledge_record_success(monkeypatch, mock_session):
         "knowledge_describe": "Test knowledge description",
         "user_id": "test_user",
         "tenant_id": "test_tenant",
-        "embedding_model_name": "test_model"
+        "embedding_model_name": "test_model",
+        "knowledge_name": "test_knowledge"
     }
 
     # Mock KnowledgeRecord constructor
     with patch('backend.database.knowledge_db.KnowledgeRecord', return_value=mock_record):
         result = create_knowledge_record(test_query)
 
-    assert result == 123
+    assert result == {
+        "knowledge_id": 123,
+        "index_name": "test_knowledge",
+        "knowledge_name": "test_knowledge",
+    }
     session.add.assert_called_once_with(mock_record)
-    session.flush.assert_called_once()
+    assert session.flush.call_count == 1
     session.commit.assert_called_once()
 
 
@@ -179,6 +187,42 @@ def test_create_knowledge_record_exception(monkeypatch, mock_session):
     session.rollback.assert_called_once()
 
 
+def test_create_knowledge_record_generates_index_name(monkeypatch, mock_session):
+    """Test create_knowledge_record generates index_name when not provided"""
+    session, _ = mock_session
+
+    mock_record = MockKnowledgeRecord(knowledge_name="kb1")
+    mock_record.knowledge_id = 7
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.knowledge_db.get_db_session", lambda: mock_ctx)
+
+    # Deterministic index name
+    monkeypatch.setattr("backend.database.knowledge_db._generate_index_name", lambda _: "7-generated")
+
+    test_query = {
+        "knowledge_describe": "desc",
+        "user_id": "user-1",
+        "tenant_id": "tenant-1",
+        "embedding_model_name": "model-x",
+        "knowledge_name": "kb1",
+    }
+
+    with patch('backend.database.knowledge_db.KnowledgeRecord', return_value=mock_record):
+        result = create_knowledge_record(test_query)
+
+    assert result == {
+        "knowledge_id": 7,
+        "index_name": "7-generated",
+        "knowledge_name": "kb1",
+    }
+    assert mock_record.index_name == "7-generated"
+    assert session.flush.call_count == 2  # initial insert + index_name update
+    session.commit.assert_called_once()
+
+
 def test_update_knowledge_record_success(monkeypatch, mock_session):
     """Test successful update of knowledge record"""
     session, query = mock_session