Prechádzať zdrojové kódy

fix(llm): raise BizLogicError on parsing failures instead of returning error dict

jerry 2 mesiacov pred
rodič
commit
c1d1424559
2 zmenil súbory, kde vykonal 111 pridanie a 7 odobranie
  1. 13 7
      app/services/llm_service.py
  2. 98 0
      tests/test_llm_service.py

+ 13 - 7
app/services/llm_service.py

@@ -104,7 +104,7 @@ class LlmService:
         api_key = cls.get_api_key()
         if not api_key:
             logger.warning("[LlmService] No LLM API Key configured.")
-            return {"error": "LLM API Key not configured"}
+            raise BizLogicError("LLM API Key not configured")
 
         url = cls.get_completions_url()
         selected_model = (model or "").strip() or cls.get_default_model()
@@ -148,22 +148,28 @@ Extract data from the text strictly based on the provided JSON Schema.
                             error_text = await response.text()
                             logger.error(f"[LlmService] HTTP {response.status} from {url}: {error_text}")
                             if attempt == max_retries:
-                                return {"error": f"HTTP {response.status}", "detail": error_text}
+                                raise BizLogicError(f"LLM request failed: HTTP {response.status}")
                             await asyncio.sleep(0.5)
                             continue
 
                         result = await response.json()
                         choices = result.get("choices", [])
                         if not choices:
-                            return {"error": "No completion choices returned"}
+                            raise BizLogicError("LLM response did not contain completion choices")
 
                         content_str = choices[0].get("message", {}).get("content", "")
-                        return cls.clean_json_response(content_str)
-
+                        try:
+                            return cls.clean_json_response(content_str)
+                        except Exception as e:
+                            logger.error(f"[LlmService] Failed to parse JSON from LLM response: {content_str}, error: {e}")
+                            raise BizLogicError("Failed to parse valid JSON from LLM response")
+
+            except BizLogicError:
+                raise
             except Exception as e:
                 logger.error(f"[LlmService] Exception on attempt {attempt + 1}: {e}")
                 if attempt == max_retries:
-                    return {"error": "LLM invocation error", "detail": str(e)}
+                    raise BizLogicError(f"LLM invocation error: {str(e)}")
                 await asyncio.sleep(0.5)
 
-        return {"error": "LLM request failed"}
+        raise BizLogicError("LLM request failed")

+ 98 - 0
tests/test_llm_service.py

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+import unittest
+from unittest.mock import patch, MagicMock, AsyncMock
+from app.services.llm_service import LlmService
+from app.core.biz_exception import BizLogicError
+
+
+class TestLlmService(unittest.IsolatedAsyncioTestCase):
+    async def test_no_api_key_raises_biz_logic_error(self):
+        with patch.object(LlmService, "get_api_key", return_value=""):
+            with self.assertRaises(BizLogicError) as ctx:
+                await LlmService.parse_data_async(
+                    user_text="test",
+                    json_schema={"type": "object"},
+                )
+            self.assertEqual(ctx.exception.message, "LLM API Key not configured")
+            self.assertEqual(ctx.exception.code, 40001)
+
+    def _create_mock_session_cls(self, mock_response):
+        mock_post = MagicMock()
+        mock_post.__aenter__ = AsyncMock(return_value=mock_response)
+        mock_post.__aexit__ = AsyncMock(return_value=None)
+
+        mock_session = MagicMock()
+        mock_session.post = MagicMock(return_value=mock_post)
+        mock_session.__aenter__ = AsyncMock(return_value=mock_session)
+        mock_session.__aexit__ = AsyncMock(return_value=None)
+
+        mock_session_cls = MagicMock(return_value=mock_session)
+        return mock_session_cls
+
+    @patch("aiohttp.ClientSession")
+    async def test_empty_choices_raises_biz_logic_error(self, mock_session_cls):
+        mock_response = AsyncMock()
+        mock_response.status = 200
+        mock_response.json = AsyncMock(return_value={"choices": []})
+
+        mock_session_cls.side_effect = self._create_mock_session_cls(mock_response)
+
+        with patch.object(LlmService, "get_api_key", return_value="test-key"):
+            with self.assertRaises(BizLogicError) as ctx:
+                await LlmService.parse_data_async(
+                    user_text="test",
+                    json_schema={"type": "object"},
+                )
+            self.assertEqual(ctx.exception.message, "LLM response did not contain completion choices")
+
+    @patch("aiohttp.ClientSession")
+    async def test_invalid_json_raises_biz_logic_error(self, mock_session_cls):
+        mock_response = AsyncMock()
+        mock_response.status = 200
+        mock_response.json = AsyncMock(return_value={
+            "choices": [{"message": {"content": "not-valid-json"}}]
+        })
+
+        mock_session_cls.side_effect = self._create_mock_session_cls(mock_response)
+
+        with patch.object(LlmService, "get_api_key", return_value="test-key"):
+            with self.assertRaises(BizLogicError) as ctx:
+                await LlmService.parse_data_async(
+                    user_text="test",
+                    json_schema={"type": "object"},
+                )
+            self.assertEqual(ctx.exception.message, "Failed to parse valid JSON from LLM response")
+
+    @patch("aiohttp.ClientSession")
+    async def test_valid_json_returns_dict(self, mock_session_cls):
+        mock_response = AsyncMock()
+        mock_response.status = 200
+        mock_response.json = AsyncMock(return_value={
+            "choices": [{"message": {"content": '{"first_name": "JOHN", "last_name": "DOE"}'}}]
+        })
+
+        mock_session_cls.side_effect = self._create_mock_session_cls(mock_response)
+
+        with patch.object(LlmService, "get_api_key", return_value="test-key"):
+            result = await LlmService.parse_data_async(
+                user_text="test",
+                json_schema={"type": "object"},
+            )
+            self.assertEqual(result, {"first_name": "JOHN", "last_name": "DOE"})
+
+    @patch("aiohttp.ClientSession")
+    async def test_http_error_raises_biz_logic_error(self, mock_session_cls):
+        mock_response = AsyncMock()
+        mock_response.status = 500
+        mock_response.text = AsyncMock(return_value="Internal Server Error")
+
+        mock_session_cls.side_effect = self._create_mock_session_cls(mock_response)
+
+        with patch.object(LlmService, "get_api_key", return_value="test-key"):
+            with self.assertRaises(BizLogicError) as ctx:
+                await LlmService.parse_data_async(
+                    user_text="test",
+                    json_schema={"type": "object"},
+                    max_retries=0,
+                )
+            self.assertIn("LLM request failed: HTTP 500", ctx.exception.message)