♻️ Improvement: Now ModelEngine interface won't wait till timeout while related environment variables are not set

Author: Phinease

backend/apps/me_model_managment_app.py

@@ -5,8 +5,7 @@
 from fastapi.responses import JSONResponse
 
 from consts.exceptions import TimeoutException, NotFoundException, MEConnectionException
-from consts.model import ModelConnectStatusEnum
-from services.me_model_management_service import get_me_models_impl
+from services.me_model_management_service import get_me_models_impl, check_me_variable_set
 from services.model_health_service import check_me_connectivity_impl
 
 router = APIRouter(prefix="/me")
@@ -23,6 +22,15 @@ async def get_me_models(
     Get list of models from model engine API
     """
     try:
+        # Pre-check ME environment variables; return empty list if not configured
+        if not await check_me_variable_set():
+            return JSONResponse(
+                status_code=HTTPStatus.OK,
+                content={
+                    "message": "Retrieve skipped",
+                    "data": []
+                }
+            )
         filtered_result = await get_me_models_impl(timeout=timeout, type=type)
         return JSONResponse(
             status_code=HTTPStatus.OK,
@@ -48,12 +56,21 @@ async def check_me_connectivity(timeout: int = Query(default=2, description="Tim
     Health check from model engine API
     """
     try:
+        # Pre-check ME environment variables; return not connected if not configured
+        if not await check_me_variable_set():
+            return JSONResponse(
+                status_code=HTTPStatus.OK,
+                content={
+                    "connectivity": False,
+                    "message": "ModelEngine platform necessary environment variables not configured. Healthcheck skipped.",
+                }
+            )
         await check_me_connectivity_impl(timeout)
         return JSONResponse(
             status_code=HTTPStatus.OK,
             content={
                 "connectivity": True,
-                "message": "ModelEngine model connect successfully.",
+                "message": "ModelEngine platform connect successfully.",
             }
         )
     except MEConnectionException as e:

backend/services/me_model_management_service.py

@@ -50,3 +50,12 @@ async def get_me_models_impl(timeout: int = 2, type: str = "") -> List:
         raise TimeoutException("Request timeout.")
     except Exception as e:
         raise Exception(f"Failed to get model list: {str(e)}.")
+
+
+async def check_me_variable_set() -> bool:
+    """
+    Check if the ME environment variables are correctly set.
+    Returns:
+        bool: True if both MODEL_ENGINE_APIKEY and MODEL_ENGINE_HOST are set and non-empty, False otherwise.
+    """
+    return bool(MODEL_ENGINE_APIKEY and MODEL_ENGINE_HOST)

test/backend/app/test_me_model_managment_app.py

@@ -193,13 +193,26 @@ async def mock_list_models_with_filter(type: str = Query(None)):
     assert response_data["data"][0]["name"] == "model2"
 
 
+@pytest.mark.asyncio
+async def test_get_me_models_env_not_configured_returns_skip_message_and_empty_list():
+    """When ME env not configured, endpoint returns 200 with skip message and empty data."""
+    with patch('backend.apps.me_model_managment_app.check_me_variable_set', AsyncMock(return_value=False)):
+        response = client.get("/me/model/list")
+
+    assert response.status_code == HTTPStatus.OK
+    data = response.json()
+    assert data["message"] == "Retrieve skipped"
+    assert data["data"] == []
+
+
 @pytest.mark.asyncio
 async def test_get_me_models_not_found_filter():
     # Patch the service impl to raise NotFoundException so the route returns 404
-    with patch('backend.apps.me_model_managment_app.get_me_models_impl') as mock_impl:
-        mock_impl.side_effect = NotFoundException(
-            "No models found with type 'nonexistent'.")
-        response = client.get("/me/model/list?type=nonexistent")
+    with patch('backend.apps.me_model_managment_app.check_me_variable_set', AsyncMock(return_value=True)):
+        with patch('backend.apps.me_model_managment_app.get_me_models_impl') as mock_impl:
+            mock_impl.side_effect = NotFoundException(
+                "No models found with type 'nonexistent'.")
+            response = client.get("/me/model/list?type=nonexistent")
 
     # Assertions - route maps NotFoundException -> 404 and raises HTTPException with detail
     assert response.status_code == HTTPStatus.NOT_FOUND
@@ -211,10 +224,11 @@ async def test_get_me_models_not_found_filter():
 async def test_get_me_models_timeout():
     """Test model list retrieval with timeout via real route"""
     # Patch service to raise TimeoutException so the real route returns 408
-    with patch('backend.apps.me_model_managment_app.get_me_models_impl') as mock_impl:
-        mock_impl.side_effect = TimeoutException("Request timeout.")
+    with patch('backend.apps.me_model_managment_app.check_me_variable_set', AsyncMock(return_value=True)):
+        with patch('backend.apps.me_model_managment_app.get_me_models_impl') as mock_impl:
+            mock_impl.side_effect = TimeoutException("Request timeout.")
 
-        response = client.get("/me/model/list")
+            response = client.get("/me/model/list")
 
     assert response.status_code == HTTPStatus.REQUEST_TIMEOUT
     body = response.json()
@@ -224,9 +238,10 @@ async def test_get_me_models_timeout():
 @pytest.mark.asyncio
 async def test_get_me_models_exception():
     """Test model list retrieval with generic exception"""
-    with patch('backend.apps.me_model_managment_app.get_me_models_impl') as mock_impl:
-        mock_impl.side_effect = Exception("boom")
-        response = client.get("/me/model/list")
+    with patch('backend.apps.me_model_managment_app.check_me_variable_set', AsyncMock(return_value=True)):
+        with patch('backend.apps.me_model_managment_app.get_me_models_impl') as mock_impl:
+            mock_impl.side_effect = Exception("boom")
+            response = client.get("/me/model/list")
 
     # Assertions
     assert response.status_code == 500
@@ -238,14 +253,15 @@ async def test_get_me_models_exception():
 async def test_get_me_models_success_response():
     """Test successful model list retrieval with proper JSONResponse format"""
     # Mock the service implementation to return test data
-    with patch('backend.apps.me_model_managment_app.get_me_models_impl') as mock_impl:
-        mock_impl.return_value = [
-            {"name": "model1", "type": "embed", "version": "1.0"},
-            {"name": "model2", "type": "chat", "version": "1.0"}
-        ]
+    with patch('backend.apps.me_model_managment_app.check_me_variable_set', AsyncMock(return_value=True)):
+        with patch('backend.apps.me_model_managment_app.get_me_models_impl') as mock_impl:
+            mock_impl.return_value = [
+                {"name": "model1", "type": "embed", "version": "1.0"},
+                {"name": "model2", "type": "chat", "version": "1.0"}
+            ]
 
-        # Test the endpoint
-        response = client.get("/me/model/list")
+            # Test the endpoint
+            response = client.get("/me/model/list")
 
         # Assertions
         assert response.status_code == HTTPStatus.OK
@@ -258,39 +274,69 @@ async def test_get_me_models_success_response():
         assert len(response_data["data"]) == 2
 
 
+@pytest.mark.asyncio
+async def test_check_me_connectivity_env_not_configured_returns_skip_message():
+    """When ME env not configured, healthcheck returns connectivity False and skip message."""
+    with patch('backend.apps.me_model_managment_app.check_me_variable_set', AsyncMock(return_value=False)):
+        response = client.get("/me/healthcheck")
+
+    assert response.status_code == HTTPStatus.OK
+    body = response.json()
+    assert body["connectivity"] is False
+    assert body["message"] == "ModelEngine platform necessary environment variables not configured. Healthcheck skipped."
+
+
 @pytest.mark.asyncio
 async def test_check_me_connectivity_success():
     """Test successful ME connectivity check"""
     # Mock the check_me_connectivity_impl function in the app module
-    with patch('backend.apps.me_model_managment_app.check_me_connectivity_impl') as mock_connectivity:
-        mock_connectivity.return_value = (
-            HTTPStatus.OK,
-            "Connection successful",
-            {
-                "status": "Connected",
-                "desc": "Connection successful",
-                "connect_status": "available"
-            }
-        )
+    with patch('backend.apps.me_model_managment_app.check_me_variable_set', AsyncMock(return_value=True)):
+        with patch('backend.apps.me_model_managment_app.check_me_connectivity_impl') as mock_connectivity:
+            mock_connectivity.return_value = (
+                HTTPStatus.OK,
+                "Connection successful",
+                {
+                    "status": "Connected",
+                    "desc": "Connection successful",
+                    "connect_status": "available"
+                }
+            )
 
-        # Test with TestClient
-        response = client.get("/me/healthcheck")
+            # Test with TestClient
+            response = client.get("/me/healthcheck")
 
         # Assertions
         assert response.status_code == 200
         response_data = response.json()
         assert response_data["connectivity"]
+        # Updated success message string
+        with patch('backend.apps.me_model_managment_app.check_me_variable_set', AsyncMock(return_value=True)):
+            with patch('backend.apps.me_model_managment_app.check_me_connectivity_impl') as mock_connectivity2:
+                mock_connectivity2.return_value = (
+                    HTTPStatus.OK,
+                    "Connection successful",
+                    {
+                        "status": "Connected",
+                        "desc": "Connection successful",
+                        "connect_status": "available"
+                    }
+                )
+                response2 = client.get("/me/healthcheck")
+                assert response2.status_code == 200
+                assert response2.json()[
+                    "message"] == "ModelEngine platform connect successfully."
 
 
 @pytest.mark.asyncio
 async def test_check_me_connectivity_failure():
     """Trigger MEConnectionException to simulate connectivity failure"""
     # Patch the impl to raise MEConnectionException so the route returns 503
-    with patch('backend.apps.me_model_managment_app.check_me_connectivity_impl') as mock_connectivity:
-        mock_connectivity.side_effect = MEConnectionException(
-            "Downstream 404 or similar")
+    with patch('backend.apps.me_model_managment_app.check_me_variable_set', AsyncMock(return_value=True)):
+        with patch('backend.apps.me_model_managment_app.check_me_connectivity_impl') as mock_connectivity:
+            mock_connectivity.side_effect = MEConnectionException(
+                "Downstream 404 or similar")
 
-        response = client.get("/me/healthcheck")
+            response = client.get("/me/healthcheck")
 
     assert response.status_code == HTTPStatus.SERVICE_UNAVAILABLE
 
@@ -299,10 +345,12 @@ async def test_check_me_connectivity_failure():
 async def test_check_me_connectivity_timeout():
     """Test ME connectivity check with timeout"""
     # Mock the impl to raise TimeoutException so the route returns 408
-    with patch('backend.apps.me_model_managment_app.check_me_connectivity_impl') as mock_connectivity:
-        mock_connectivity.side_effect = TimeoutException("timeout simulated")
+    with patch('backend.apps.me_model_managment_app.check_me_variable_set', AsyncMock(return_value=True)):
+        with patch('backend.apps.me_model_managment_app.check_me_connectivity_impl') as mock_connectivity:
+            mock_connectivity.side_effect = TimeoutException(
+                "timeout simulated")
 
-        response = client.get("/me/healthcheck")
+            response = client.get("/me/healthcheck")
 
     # Assertions - route maps TimeoutException -> 408 and returns status/desc/connect_status
     assert response.status_code == HTTPStatus.REQUEST_TIMEOUT
@@ -312,10 +360,12 @@ async def test_check_me_connectivity_timeout():
 async def test_check_me_connectivity_generic_exception():
     """Test ME connectivity check with generic exception"""
     # Mock the impl to raise a generic Exception so the route returns 500
-    with patch('backend.apps.me_model_managment_app.check_me_connectivity_impl') as mock_connectivity:
-        mock_connectivity.side_effect = Exception("Unexpected error occurred")
+    with patch('backend.apps.me_model_managment_app.check_me_variable_set', AsyncMock(return_value=True)):
+        with patch('backend.apps.me_model_managment_app.check_me_connectivity_impl') as mock_connectivity:
+            mock_connectivity.side_effect = Exception(
+                "Unexpected error occurred")
 
-        response = client.get("/me/healthcheck")
+            response = client.get("/me/healthcheck")
 
     # Assertions - route maps generic Exception -> 500 and returns status/desc/connect_status
     assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR