fix: correct import path for manual retry state and update route definition

- Fixed the import path for the manual retry state controller in routes.py.
- Updated the route definition for manual retry to include a leading slash for consistency.
- Added a new controller file for manual retry state functionality, implementing the logic for handling manual retries.
- Introduced unit tests for the manual retry request and response models, ensuring validation and functionality.
- Enhanced unit tests for the manual retry state route, covering various scenarios including valid and invalid API keys.

These changes improve the structure and reliability of the manual retry feature.

Author: NiveditJain

…ager/app/controller/manul_retry_state.py …ger/app/controller/manual_retry_state.pystate-manager/app/controller/manul_retry_state.py renamed to state-manager/app/controller/manual_retry_state.py state-manager/app/controller/manul_retry_state.py renamed to state-manager/app/controller/manual_retry_state.py

@@ -52,7 +52,7 @@
 
 # manual_retry
 from .models.manual_retry import ManualRetryRequestModel, ManualRetryResponseModel
-from .controller.manul_retry_state import manual_retry_state
+from .controller.manual_retry_state import manual_retry_state
 
 
 logger = LogsManager().get_logger()
@@ -181,7 +181,7 @@ async def re_enqueue_after_state_route(namespace_name: str, state_id: str, body:
     return await re_queue_after_signal(namespace_name, PydanticObjectId(state_id), body, x_exosphere_request_id)
 
 @router.post(
-    "state/{state_id}/manual-retry",
+    "/state/{state_id}/manual-retry",
     response_model=ManualRetryResponseModel,
     status_code=status.HTTP_200_OK,
     response_description="State manual retry successfully",

state-manager/app/routes.py

@@ -0,0 +1,241 @@
+import pytest
+from pydantic import ValidationError
+
+from app.models.manual_retry import ManualRetryRequestModel, ManualRetryResponseModel
+from app.models.state_status_enum import StateStatusEnum
+
+
+class TestManualRetryRequestModel:
+    """Test cases for ManualRetryRequestModel"""
+
+    def test_manual_retry_request_model_valid_data(self):
+        """Test ManualRetryRequestModel with valid fanout_id"""
+        # Arrange & Act
+        fanout_id = "test-fanout-id-123"
+        model = ManualRetryRequestModel(fanout_id=fanout_id)
+        
+        # Assert
+        assert model.fanout_id == fanout_id
+
+    def test_manual_retry_request_model_empty_fanout_id(self):
+        """Test ManualRetryRequestModel with empty fanout_id"""
+        # Arrange & Act
+        fanout_id = ""
+        model = ManualRetryRequestModel(fanout_id=fanout_id)
+        
+        # Assert
+        assert model.fanout_id == fanout_id
+
+    def test_manual_retry_request_model_uuid_fanout_id(self):
+        """Test ManualRetryRequestModel with UUID fanout_id"""
+        # Arrange & Act
+        fanout_id = "550e8400-e29b-41d4-a716-446655440000"
+        model = ManualRetryRequestModel(fanout_id=fanout_id)
+        
+        # Assert
+        assert model.fanout_id == fanout_id
+
+    def test_manual_retry_request_model_long_fanout_id(self):
+        """Test ManualRetryRequestModel with long fanout_id"""
+        # Arrange & Act
+        fanout_id = "a" * 1000  # Very long string
+        model = ManualRetryRequestModel(fanout_id=fanout_id)
+        
+        # Assert
+        assert model.fanout_id == fanout_id
+
+    def test_manual_retry_request_model_special_characters_fanout_id(self):
+        """Test ManualRetryRequestModel with special characters in fanout_id"""
+        # Arrange & Act
+        fanout_id = "test-fanout@#$%^&*()_+-={}[]|\\:;\"'<>?,./"
+        model = ManualRetryRequestModel(fanout_id=fanout_id)
+        
+        # Assert
+        assert model.fanout_id == fanout_id
+
+    def test_manual_retry_request_model_missing_fanout_id(self):
+        """Test ManualRetryRequestModel with missing fanout_id field"""
+        # Arrange & Act & Assert
+        with pytest.raises(ValidationError) as exc_info:
+            ManualRetryRequestModel() # type: ignore
+        
+        assert "fanout_id" in str(exc_info.value)
+        assert "Field required" in str(exc_info.value)
+
+    def test_manual_retry_request_model_none_fanout_id(self):
+        """Test ManualRetryRequestModel with None fanout_id"""
+        # Arrange & Act & Assert
+        with pytest.raises(ValidationError) as exc_info:
+            ManualRetryRequestModel(fanout_id=None) # type: ignore
+        
+        assert "fanout_id" in str(exc_info.value)
+
+    def test_manual_retry_request_model_numeric_fanout_id(self):
+        """Test ManualRetryRequestModel with numeric fanout_id (should fail validation)"""
+        # Arrange & Act & Assert
+        with pytest.raises(ValidationError) as exc_info:
+            ManualRetryRequestModel(fanout_id=12345) # type: ignore
+        
+        assert "string_type" in str(exc_info.value)
+
+    def test_manual_retry_request_model_dict_representation(self):
+        """Test ManualRetryRequestModel dict representation"""
+        # Arrange & Act
+        fanout_id = "test-fanout-id"
+        model = ManualRetryRequestModel(fanout_id=fanout_id)
+        
+        # Assert
+        expected_dict = {"fanout_id": fanout_id}
+        assert model.model_dump() == expected_dict
+
+    def test_manual_retry_request_model_json_serialization(self):
+        """Test ManualRetryRequestModel JSON serialization"""
+        # Arrange & Act
+        fanout_id = "test-fanout-id"
+        model = ManualRetryRequestModel(fanout_id=fanout_id)
+        
+        # Assert
+        json_str = model.model_dump_json()
+        assert f'"fanout_id":"{fanout_id}"' in json_str
+
+
+class TestManualRetryResponseModel:
+    """Test cases for ManualRetryResponseModel"""
+
+    def test_manual_retry_response_model_valid_data(self):
+        """Test ManualRetryResponseModel with valid data"""
+        # Arrange & Act
+        state_id = "507f1f77bcf86cd799439011"
+        status = StateStatusEnum.CREATED
+        model = ManualRetryResponseModel(id=state_id, status=status)
+        
+        # Assert
+        assert model.id == state_id
+        assert model.status == status
+
+    def test_manual_retry_response_model_all_status_types(self):
+        """Test ManualRetryResponseModel with all possible status values"""
+        # Arrange & Act & Assert
+        state_id = "507f1f77bcf86cd799439011"
+        
+        for status in StateStatusEnum:
+            model = ManualRetryResponseModel(id=state_id, status=status)
+            assert model.id == state_id
+            assert model.status == status
+
+    def test_manual_retry_response_model_created_status(self):
+        """Test ManualRetryResponseModel with CREATED status"""
+        # Arrange & Act
+        state_id = "507f1f77bcf86cd799439011"
+        status = StateStatusEnum.CREATED
+        model = ManualRetryResponseModel(id=state_id, status=status)
+        
+        # Assert
+        assert model.id == state_id
+        assert model.status == StateStatusEnum.CREATED
+
+    def test_manual_retry_response_model_retry_created_status(self):
+        """Test ManualRetryResponseModel with RETRY_CREATED status"""
+        # Arrange & Act
+        state_id = "507f1f77bcf86cd799439011"
+        status = StateStatusEnum.RETRY_CREATED
+        model = ManualRetryResponseModel(id=state_id, status=status)
+        
+        # Assert
+        assert model.id == state_id
+        assert model.status == StateStatusEnum.RETRY_CREATED
+
+    def test_manual_retry_response_model_missing_id(self):
+        """Test ManualRetryResponseModel with missing id field"""
+        # Arrange & Act & Assert
+        with pytest.raises(ValidationError) as exc_info:
+            ManualRetryResponseModel(status=StateStatusEnum.CREATED) # type: ignore
+        
+        assert "id" in str(exc_info.value)
+        assert "Field required" in str(exc_info.value)
+
+    def test_manual_retry_response_model_missing_status(self):
+        """Test ManualRetryResponseModel with missing status field"""
+        # Arrange & Act & Assert
+        with pytest.raises(ValidationError) as exc_info:
+            ManualRetryResponseModel(id="507f1f77bcf86cd799439011") # type: ignore
+        
+        assert "status" in str(exc_info.value)
+        assert "Field required" in str(exc_info.value)
+
+    def test_manual_retry_response_model_none_id(self):
+        """Test ManualRetryResponseModel with None id"""
+        # Arrange & Act & Assert
+        with pytest.raises(ValidationError) as exc_info:
+            ManualRetryResponseModel(id=None, status=StateStatusEnum.CREATED) # type: ignore
+        
+        assert "id" in str(exc_info.value)
+
+    def test_manual_retry_response_model_none_status(self):
+        """Test ManualRetryResponseModel with None status"""
+        # Arrange & Act & Assert
+        with pytest.raises(ValidationError) as exc_info:
+            ManualRetryResponseModel(id="507f1f77bcf86cd799439011", status=None) # type: ignore
+        
+        assert "status" in str(exc_info.value)
+
+    def test_manual_retry_response_model_invalid_status(self):
+        """Test ManualRetryResponseModel with invalid status"""
+        # Arrange & Act & Assert
+        with pytest.raises(ValidationError) as exc_info:
+            ManualRetryResponseModel(id="507f1f77bcf86cd799439011", status="INVALID_STATUS") # type: ignore
+        
+        assert "status" in str(exc_info.value)
+
+    def test_manual_retry_response_model_numeric_id(self):
+        """Test ManualRetryResponseModel with numeric id (should fail validation)"""
+        # Arrange & Act & Assert
+        with pytest.raises(ValidationError) as exc_info:
+            ManualRetryResponseModel(id=12345, status=StateStatusEnum.CREATED) # type: ignore
+        
+        assert "string_type" in str(exc_info.value)
+
+    def test_manual_retry_response_model_dict_representation(self):
+        """Test ManualRetryResponseModel dict representation"""
+        # Arrange & Act
+        state_id = "507f1f77bcf86cd799439011"
+        status = StateStatusEnum.CREATED
+        model = ManualRetryResponseModel(id=state_id, status=status)
+        
+        # Assert
+        expected_dict = {"id": state_id, "status": status}
+        assert model.model_dump() == expected_dict
+
+    def test_manual_retry_response_model_json_serialization(self):
+        """Test ManualRetryResponseModel JSON serialization"""
+        # Arrange & Act
+        state_id = "507f1f77bcf86cd799439011"
+        status = StateStatusEnum.CREATED
+        model = ManualRetryResponseModel(id=state_id, status=status)
+        
+        # Assert
+        json_str = model.model_dump_json()
+        assert f'"id":"{state_id}"' in json_str
+        assert f'"status":"{status.value}"' in json_str
+
+    def test_manual_retry_response_model_empty_id(self):
+        """Test ManualRetryResponseModel with empty string id"""
+        # Arrange & Act
+        state_id = ""
+        status = StateStatusEnum.CREATED
+        model = ManualRetryResponseModel(id=state_id, status=status)
+        
+        # Assert
+        assert model.id == state_id
+        assert model.status == status
+
+    def test_manual_retry_response_model_long_id(self):
+        """Test ManualRetryResponseModel with very long id"""
+        # Arrange & Act
+        state_id = "a" * 1000  # Very long string
+        status = StateStatusEnum.CREATED
+        model = ManualRetryResponseModel(id=state_id, status=status)
+        
+        # Assert
+        assert model.id == state_id
+        assert model.status == status 

state-manager/tests/unit/models/test_manual_retry.py

@@ -8,6 +8,7 @@
 from app.models.secrets_response import SecretsResponseModel
 from app.models.list_models import ListRegisteredNodesResponse, ListGraphTemplatesResponse
 from app.models.run_models import RunsResponse, RunListItem, RunStatusEnum
+from app.models.manual_retry import ManualRetryRequestModel, ManualRetryResponseModel
 
 
 import pytest
@@ -32,6 +33,7 @@ def test_router_has_correct_routes(self):
         assert any('/v0/namespace/{namespace_name}/state/{state_id}/errored' in path for path in paths)
         assert any('/v0/namespace/{namespace_name}/state/{state_id}/prune' in path for path in paths)
         assert any('/v0/namespace/{namespace_name}/state/{state_id}/re-enqueue-after' in path for path in paths)
+        assert any('/v0/namespace/{namespace_name}/state/{state_id}/manual-retry' in path for path in paths)
 
         # Graph template routes (there are two /graph/{graph_name} routes - GET and PUT)
         assert any('/v0/namespace/{namespace_name}/graph/{graph_name}' in path for path in paths)
@@ -273,6 +275,26 @@ def test_list_graph_templates_response_validation(self):
         assert model.namespace == "test"
         assert model.count == 0
 
+    def test_manual_retry_request_model_validation(self):
+        """Test ManualRetryRequestModel validation"""
+        # Test with valid data
+        valid_data = {"fanout_id": "test-fanout-id-123"}
+        model = ManualRetryRequestModel(**valid_data)
+        assert model.fanout_id == "test-fanout-id-123"
+
+    def test_manual_retry_response_model_validation(self):
+        """Test ManualRetryResponseModel validation"""
+        from app.models.state_status_enum import StateStatusEnum
+        
+        # Test with valid data
+        valid_data = {
+            "id": "507f1f77bcf86cd799439011",
+            "status": StateStatusEnum.CREATED
+        }
+        model = ManualRetryResponseModel(**valid_data)
+        assert model.id == "507f1f77bcf86cd799439011"
+        assert model.status == StateStatusEnum.CREATED
+
 
 
 
@@ -295,7 +317,8 @@ def test_route_handlers_exist(self):
             list_graph_templates_route,
             get_runs_route,
             get_graph_structure_route,
-            get_node_run_details_route
+            get_node_run_details_route,
+            manual_retry_state_route
 
         )
 
@@ -313,6 +336,7 @@ def test_route_handlers_exist(self):
         assert callable(get_runs_route)
         assert callable(get_graph_structure_route)
         assert callable(get_node_run_details_route)
+        assert callable(manual_retry_state_route)
 
 
 
@@ -1033,4 +1057,64 @@ async def test_get_node_run_details_route_with_invalid_api_key(self, mock_get_no
 
         assert exc_info.value.status_code == 401
         assert exc_info.value.detail == "Invalid API key"
-        mock_get_node_run_details.assert_not_called()
+        mock_get_node_run_details.assert_not_called()
+
+    @patch('app.routes.manual_retry_state')
+    async def test_manual_retry_state_route_with_valid_api_key(self, mock_manual_retry_state, mock_request):
+        """Test manual_retry_state_route with valid API key"""
+        from app.routes import manual_retry_state_route
+        
+        # Arrange
+        mock_manual_retry_state.return_value = MagicMock()
+        body = ManualRetryRequestModel(fanout_id="test-fanout-id")
+        
+        # Act
+        result = await manual_retry_state_route("test_namespace", "507f1f77bcf86cd799439011", body, mock_request, "valid_key")
+        
+        # Assert
+        mock_manual_retry_state.assert_called_once()
+        call_args = mock_manual_retry_state.call_args
+        assert call_args[0][0] == "test_namespace"  # namespace_name
+        assert str(call_args[0][1]) == "507f1f77bcf86cd799439011"  # state_id as PydanticObjectId
+        assert call_args[0][2] == body  # body
+        assert call_args[0][3] == "test-request-id"  # x_exosphere_request_id
+        assert result == mock_manual_retry_state.return_value
+
+    @patch('app.routes.manual_retry_state')
+    async def test_manual_retry_state_route_with_invalid_api_key(self, mock_manual_retry_state, mock_request):
+        """Test manual_retry_state_route with invalid API key"""
+        from app.routes import manual_retry_state_route
+        from fastapi import HTTPException
+        
+        # Arrange
+        body = ManualRetryRequestModel(fanout_id="test-fanout-id")
+        
+        # Act & Assert
+        with pytest.raises(HTTPException) as exc_info:
+            await manual_retry_state_route("test_namespace", "507f1f77bcf86cd799439011", body, mock_request, None) # type: ignore
+        
+        assert exc_info.value.status_code == 401
+        assert exc_info.value.detail == "Invalid API key"
+        mock_manual_retry_state.assert_not_called()
+
+    @patch('app.routes.manual_retry_state')
+    async def test_manual_retry_state_route_without_request_id(self, mock_manual_retry_state, mock_request_no_id):
+        """Test manual_retry_state_route without x_exosphere_request_id"""
+        from app.routes import manual_retry_state_route
+        
+        # Arrange
+        mock_manual_retry_state.return_value = MagicMock()
+        body = ManualRetryRequestModel(fanout_id="test-fanout-id")
+        
+        # Act
+        result = await manual_retry_state_route("test_namespace", "507f1f77bcf86cd799439011", body, mock_request_no_id, "valid_key")
+        
+        # Assert
+        mock_manual_retry_state.assert_called_once()
+        call_args = mock_manual_retry_state.call_args
+        assert call_args[0][0] == "test_namespace"  # namespace_name
+        assert str(call_args[0][1]) == "507f1f77bcf86cd799439011"  # state_id as PydanticObjectId
+        assert call_args[0][2] == body  # body
+        # Should generate a UUID when no request ID is present
+        assert len(call_args[0][3]) > 0  # x_exosphere_request_id should be generated
+        assert result == mock_manual_retry_state.return_value