♻️ Translate error messages and fix test cases

Author: Mermaid97

backend/services/user_management_service.py

@@ -88,21 +88,21 @@ async def check_auth_service_health() -> bool:
     try:
         supabase_url = os.getenv("SUPABASE_URL")
         supabase_key = os.getenv("SUPABASE_KEY")
-        
+
         health_url = f'{supabase_url}/auth/v1/health'
         headers = {'apikey': supabase_key}
-        
+
         async with aiohttp.ClientSession() as session:
             async with session.get(health_url, headers=headers) as response:
                 if not response.ok:
                     return False
-                
+
                 data = await response.json()
                 # Check if the service is available by checking if the response contains the name field and its value is "GoTrue"
                 is_available = data and data.get("name") == "GoTrue"
-                
+
                 return is_available
-                    
+
     except aiohttp.ClientError as e:
         logging.error(f"Auth service connection failed: {str(e)}")
         return False
@@ -117,7 +117,8 @@ async def signup_user(email: EmailStr,
                       invite_code: Optional[str] = None):
     """User registration"""
     client = get_supabase_client()
-    logging.info(f"Receive registration request: email={email}, is_admin={is_admin}")
+    logging.info(
+        f"Receive registration request: email={email}, is_admin={is_admin}")
     if is_admin:
         await verify_invite_code(invite_code)
 
@@ -138,7 +139,8 @@ async def signup_user(email: EmailStr,
         # Create user tenant relationship
         insert_user_tenant(user_id=user_id, tenant_id=tenant_id)
 
-        logging.info(f"User {email} registered successfully, role: {user_role}, tenant: {tenant_id}")
+        logging.info(
+            f"User {email} registered successfully, role: {user_role}, tenant: {tenant_id}")
 
         if is_admin:
             await generate_tts_stt_4_admin(tenant_id, user_id)
@@ -147,7 +149,8 @@ async def signup_user(email: EmailStr,
     else:
         logging.error(
             "Supabase registration request returned no user object")
-        raise UserRegistrationException("Registration service is temporarily unavailable, please try again later")
+        raise UserRegistrationException(
+            "Registration service is temporarily unavailable, please try again later")
 
 
 async def parse_supabase_response(is_admin, response, user_role):
@@ -157,7 +160,7 @@ async def parse_supabase_response(is_admin, response, user_role):
         "email": response.user.email,
         "role": user_role
     }
-    
+
     session_data = None
     if response.session:
         session_data = {
@@ -166,7 +169,7 @@ async def parse_supabase_response(is_admin, response, user_role):
             "expires_at": calculate_expires_at(response.session.access_token),
             "expires_in_seconds": get_jwt_expiry_seconds(response.session.access_token)
         }
-    
+
     return {
         "user": user_data,
         "session": session_data,
@@ -206,7 +209,8 @@ async def generate_tts_stt_4_admin(tenant_id, user_id):
 
 
 async def verify_invite_code(invite_code):
-    logging.info("detect admin registration request, start verifying invite code")
+    logging.info(
+        "detect admin registration request, start verifying invite code")
     logging.info(f"The INVITE_CODE obtained from consts.const: {INVITE_CODE}")
     if not INVITE_CODE:
         logging.error("please check the INVITE_CODE environment variable")
@@ -219,7 +223,8 @@ async def verify_invite_code(invite_code):
     if invite_code != INVITE_CODE:
         logging.warning(
             f"Admin invite code verification failed: user provided='{invite_code}', system configured='{INVITE_CODE}'")
-        raise IncorrectInviteCodeException("Please enter the correct admin invite code")
+        raise IncorrectInviteCodeException(
+            "Please enter the correct admin invite code")
     logging.info("Admin invite code verification successful")
 
 
@@ -246,21 +251,21 @@ async def signin_user(email: EmailStr,
         f"User {email} logged in successfully, session validity is {expiry_seconds} seconds, role: {user_role}")
 
     return {
-            "message":f"Login successful, session validity is {expiry_seconds} seconds",
-            "data":{
-                "user": {
-                    "id": response.user.id,
-                    "email": response.user.email,
-                    "role": user_role
-                },
-                "session": {
-                    "access_token": response.session.access_token,
-                    "refresh_token": response.session.refresh_token,
-                    "expires_at": expires_at,
-                    "expires_in_seconds": expiry_seconds
-                }
+        "message": f"Login successful, session validity is {expiry_seconds} seconds",
+        "data": {
+            "user": {
+                "id": response.user.id,
+                "email": response.user.email,
+                "role": user_role
+            },
+            "session": {
+                "access_token": response.session.access_token,
+                "refresh_token": response.session.refresh_token,
+                "expires_at": expires_at,
+                "expires_in_seconds": expiry_seconds
             }
         }
+    }
 
 
 async def refresh_user_token(authorization, refresh_token: str):
@@ -283,10 +288,10 @@ async def get_session_by_authorization(authorization):
         if user.user_metadata and 'role' in user.user_metadata:
             user_role = user.user_metadata['role']
         return {"user": {
-                     "id": user.id,
-                     "email": user.email,
-                     "role": user_role
-                 }
-             }
+            "id": user.id,
+            "email": user.email,
+            "role": user_role
+        }
+        }
     else:
         raise ValueError("Session is invalid")

backend/utils/auth_utils.py

@@ -14,7 +14,7 @@
 from database.user_tenant_db import get_user_tenant_by_user_id
 
 # Get Supabase configuration
-SUPABASE_URL = os.getenv('SUPABASE_URL', 'http://118.31.249.152:8010')
+SUPABASE_URL = os.getenv('SUPABASE_URL')
 SUPABASE_KEY = os.getenv('SUPABASE_KEY', '')
 # Debug JWT expiration time (seconds), not set or 0 means not effective
 DEBUG_JWT_EXPIRE_SECONDS = int(os.getenv('DEBUG_JWT_EXPIRE_SECONDS', '0') or 0)

test/backend/app/test_file_management_app.py

@@ -597,6 +597,79 @@ async def test_process_text_file(mock_files):
             assert "File test.txt content" in result
 
 
+async def test_process_text_file_http_error(mock_files):
+    """Test process_text_file when HTTP request fails with non-200 status code"""
+    from backend.apps.file_management_app import process_text_file
+
+    with patch('backend.utils.config_utils.get_model_name_from_config', return_value="test-model"), \
+            patch('backend.utils.attachment_utils.get_model_name_from_config', return_value="test-model"), \
+            patch('backend.utils.attachment_utils.convert_long_text_to_text', return_value="Processed text content"), \
+            patch('backend.apps.file_management_app.convert_long_text_to_text', return_value="Processed text content"):
+
+        with patch('httpx.AsyncClient') as mock_client:
+            # Setup mock response for httpx client with error status
+            mock_response = MagicMock()
+            mock_response.status_code = 500
+            mock_response.headers = {'content-type': 'application/json'}
+            mock_response.json.return_value = {'detail': 'Internal server error'}
+            mock_response.text = 'Internal server error'
+
+            mock_client_instance = MagicMock()
+            mock_client_instance.post.return_value = asyncio.Future()
+            mock_client_instance.post.return_value.set_result(mock_response)
+            mock_client.return_value.__aenter__.return_value = mock_client_instance
+
+            # Test the function - should raise an exception
+            with pytest.raises(Exception) as exc_info:
+                await process_text_file(
+                    query="Test query",
+                    filename="test.txt",
+                    file_content=mock_files["mock_file_content"],
+                    tenant_id="tenant123",
+                    language="en"
+                )
+
+            # Verify the exception message contains the expected error details
+            assert "File processing failed (status code: 500)" in str(exc_info.value)
+            assert "Internal server error" in str(exc_info.value)
+
+
+async def test_process_text_file_http_error_non_json(mock_files):
+    """Test process_text_file when HTTP request fails with non-JSON response"""
+    from backend.apps.file_management_app import process_text_file
+
+    with patch('backend.utils.config_utils.get_model_name_from_config', return_value="test-model"), \
+            patch('backend.utils.attachment_utils.get_model_name_from_config', return_value="test-model"), \
+            patch('backend.utils.attachment_utils.convert_long_text_to_text', return_value="Processed text content"), \
+            patch('backend.apps.file_management_app.convert_long_text_to_text', return_value="Processed text content"):
+
+        with patch('httpx.AsyncClient') as mock_client:
+            # Setup mock response for httpx client with error status and non-JSON content
+            mock_response = MagicMock()
+            mock_response.status_code = 400
+            mock_response.headers = {'content-type': 'text/html'}
+            mock_response.text = 'Bad Request - HTML error page'
+
+            mock_client_instance = MagicMock()
+            mock_client_instance.post.return_value = asyncio.Future()
+            mock_client_instance.post.return_value.set_result(mock_response)
+            mock_client.return_value.__aenter__.return_value = mock_client_instance
+
+            # Test the function - should raise an exception
+            with pytest.raises(Exception) as exc_info:
+                await process_text_file(
+                    query="Test query",
+                    filename="test.txt",
+                    file_content=mock_files["mock_file_content"],
+                    tenant_id="tenant123",
+                    language="en"
+                )
+
+            # Verify the exception message contains the expected error details
+            assert "File processing failed (status code: 400)" in str(exc_info.value)
+            assert "Bad Request - HTML error page" in str(exc_info.value)
+
+
 def test_get_file_description(mock_files):
     # Import directly in the test to use the already established mocks
     from backend.apps.file_management_app import get_file_description

test/backend/app/test_model_managment_app.py

@@ -807,6 +807,53 @@ def test_batch_create_models_exception(self, mock_get_user, mock_get_existing):
         self.assertEqual(data["code"], 500)
         self.assertIn("Failed to batch create models: Database connection error", data["message"])
 
+    @patch("test_model_managment_app.create_model_record")
+    @patch("test_model_managment_app.prepare_model_dict")
+    @patch("test_model_managment_app.get_model_by_display_name")
+    @patch("test_model_managment_app.delete_model_record")
+    @patch("test_model_managment_app.get_models_by_tenant_factory_type")
+    @patch("test_model_managment_app.get_current_user_id")
+    def test_batch_create_models_max_tokens_update(self, mock_get_user, mock_get_existing, mock_delete, mock_get_by_display, mock_prepare, mock_create):
+        """Test max_tokens update when model already exists with different max_tokens"""
+        mock_get_user.return_value = (self.user_id, self.tenant_id)
+        mock_get_existing.return_value = []
+        
+        # Mock existing model with different max_tokens
+        existing_model = {
+            "model_id": "existing_model_id",
+            "max_tokens": 1000,
+            "display_name": "test_provider/existing_model"
+        }
+        
+        def get_by_display_name_side_effect(display_name, tenant_id):
+            if display_name == "test_provider/existing_model":
+                return existing_model
+            return None
+        mock_get_by_display.side_effect = get_by_display_name_side_effect
+
+        request_models = [
+            {
+                "id": "test_provider/existing_model",
+                "max_tokens": 2000  # Different max_tokens
+            }
+        ]
+
+        request_data = {
+            "models": request_models,
+            "provider": "test_provider",
+            "type": "llm",
+            "api_key": "test_key"
+        }
+
+        response = client.post("/model/batch_create_models", json=request_data, headers=self.auth_header)
+
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertEqual(data["code"], 200)
+        
+        # Verify that get_model_by_display_name was called to check for existing model
+        mock_get_by_display.assert_called_with("test_provider/existing_model", self.tenant_id)
+
     @patch("test_model_managment_app.get_provider_models", new_callable=AsyncMock)
     @patch("test_model_managment_app.get_current_user_id")
     def test_create_provider_model_silicon_success(self, mock_get_user, mock_get_provider):
@@ -1794,6 +1841,43 @@ def test_delete_embedding_model(self, mock_delete, mock_get_by_display, mock_get
         # Verify mock was called with correct model_id
         mock_delete.assert_called_once_with("embedding_id", self.user_id, self.tenant_id)
 
+    @patch("test_model_managment_app.get_current_user_id")
+    @patch("test_model_managment_app.get_model_by_display_name")
+    @patch("test_model_managment_app.delete_model_record")
+    def test_delete_multi_embedding_model(self, mock_delete, mock_get_by_display, mock_get_user):
+        """Test deletion of multi_embedding model with mutual deletion logic"""
+        mock_get_user.return_value = (self.user_id, self.tenant_id)
+        
+        # Mock multi_embedding model deletion scenario
+        # First call: initial check returns multi_embedding model
+        # Second call: loop check for "embedding" type returns None
+        # Third call: loop check for "multi_embedding" type returns the model
+        mock_get_by_display.side_effect = [
+            {
+                "model_id": "multi_embedding_id",
+                "model_type": "multi_embedding",
+                "display_name": "Test Multi Embedding"
+            },
+            None,  # No embedding model found
+            {
+                "model_id": "multi_embedding_id",
+                "model_type": "multi_embedding",
+                "display_name": "Test Multi Embedding"
+            }
+        ]
+
+        # Send request
+        response = client.post("/model/delete", params={"display_name": "Test Multi Embedding"}, headers=self.auth_header)
+
+        # Assert response
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertEqual(data["code"], 200)
+        self.assertIn("Successfully deleted model", data["message"])
+
+        # Verify mock was called with correct model_id
+        mock_delete.assert_called_once_with("multi_embedding_id", self.user_id, self.tenant_id)
+
     @patch("test_model_managment_app.get_current_user_id")
     @patch("test_model_managment_app.get_model_by_display_name")
     def test_delete_model_not_found(self, mock_get_by_display, mock_get_user):

test/backend/services/test_data_process_service.py

@@ -574,6 +574,50 @@ def test_get_all_tasks(self):
         """
         asyncio.run(self.async_test_get_all_tasks())
 
+    @patch('backend.services.data_process_service.DataProcessService._get_celery_inspector')
+    @patch('data_process.utils.get_task_info')
+    @patch('data_process.utils.get_all_task_ids_from_redis')
+    @pytest.mark.asyncio
+    async def test_get_all_tasks_redis_error(self, mock_get_redis_task_ids, mock_get_task_info, mock_get_inspector):
+        """
+        Test get_all_tasks when Redis query fails.
+        
+        This test verifies that the service handles Redis errors gracefully
+        and continues to process tasks from other sources.
+        """
+        # Setup mocks
+        mock_inspector = MagicMock()
+        mock_inspector.active.return_value = {
+            'worker1': [{'id': 'task1'}, {'id': 'task2'}]
+        }
+        mock_inspector.reserved.return_value = {
+            'worker1': [{'id': 'task3'}]
+        }
+        mock_get_inspector.return_value = mock_inspector
+
+        # Mock Redis to raise an exception
+        mock_get_redis_task_ids.side_effect = Exception("Redis connection failed")
+
+        # Setup task info mock
+        async def mock_task_info(task_id):
+            task_data = {
+                'task1': {'id': 'task1', 'status': 'ACTIVE', 'index_name': 'index1', 'task_name': 'task_name1'},
+                'task2': {'id': 'task2', 'status': 'ACTIVE', 'index_name': 'index2', 'task_name': 'task_name2'},
+                'task3': {'id': 'task3', 'status': 'RESERVED', 'index_name': 'index3', 'task_name': 'task_name3'},
+            }
+            return task_data.get(task_id, {})
+
+        mock_get_task_info.side_effect = mock_task_info
+
+        # Get all tasks - should handle Redis error gracefully
+        result = await self.service.get_all_tasks(filter=True)
+
+        # Verify result (should only include tasks from Celery, not Redis)
+        self.assertEqual(len(result), 3)
+        
+        # Verify that Redis was called and failed
+        mock_get_redis_task_ids.assert_called_once()
+
     @patch('backend.services.data_process_service.DataProcessService.get_all_tasks')
     @pytest.mark.asyncio
     async def async_test_get_index_tasks(self, mock_get_all_tasks):