[PRMP-1048] seperating handler from serbice

Author: SWhyteAnswer

lambdas/handlers/concurrency_controller_handler.py

@@ -29,4 +29,13 @@ def lambda_handler(event, _context):
     target_function, reserved_concurrency = validate_event(event)
 
     service = ConcurrencyControllerService()
-    return service.update_function_concurrency(target_function, reserved_concurrency)
+    updated_concurrency = service.update_function_concurrency(target_function, reserved_concurrency)
+    
+    return {
+        "statusCode": 200,
+        "body": {
+            "message": "Concurrency updated successfully",
+            "function": target_function,
+            "reservedConcurrency": updated_concurrency
+        }
+    }

lambdas/services/concurrency_controller_service.py

@@ -1,4 +1,5 @@
 import boto3
+from botocore.exceptions import ClientError
 from utils.audit_logging_setup import LoggingService
 
 logger = LoggingService(__name__)
@@ -21,22 +22,27 @@ def update_function_concurrency(self, target_function, reserved_concurrency):
 
             updated_concurrency = response.get("ReservedConcurrentExecutions")
 
+            if updated_concurrency is None:
+                logger.error("Response did not contain ReservedConcurrentExecutions")
+                raise ValueError("Failed to confirm concurrency update from AWS response")
+            
+            if updated_concurrency != reserved_concurrency:
+                logger.error(
+                    f"Concurrency mismatch: requested {reserved_concurrency}, "
+                    f"AWS returned {updated_concurrency}"
+                )
+                raise ValueError("Concurrency update verification failed")
+            
             logger.info(
                 f"Successfully updated concurrency for '{target_function}'. "
                 f"Reserved concurrency set to: {updated_concurrency}"
             )
 
-            return {
-                "statusCode": 200,
-                "body": {
-                    "message": "Concurrency updated successfully",
-                    "function": target_function,
-                    "reservedConcurrency": updated_concurrency
-                }
-            }
-        except self.lambda_client.exceptions.ResourceNotFoundException:
-            logger.error(f"Lambda function '{target_function}' not found")
-            raise
-        except self.lambda_client.exceptions.InvalidParameterValueException as e:
-            logger.error(f"Invalid concurrency value: {e}")
+            return updated_concurrency
+        except ClientError as e:
+            error_code = e.response.get("Error", {}).get("Code", "")
+            if error_code == "ResourceNotFoundException":
+                logger.error(f"Lambda function '{target_function}' not found")
+            else:
+                logger.error(f"Failed to update concurrency: {str(e)}")
             raise

lambdas/tests/unit/handlers/test_concurrency_controller_handler.py

@@ -36,47 +36,35 @@ def event_with_zero_concurrency():
 
 
 def test_lambda_handler_success(valid_event, context, mock_concurrency_controller_service):
-    expected_response = {
-        "statusCode": 200,
-        "body": {
-            "message": "Concurrency updated successfully",
-            "function": "test-lambda-function",
-            "reservedConcurrency": 10
-        }
-    }
-    
-    mock_concurrency_controller_service.update_function_concurrency.return_value = expected_response
+    mock_concurrency_controller_service.update_function_concurrency.return_value = 10
 
     result = lambda_handler(valid_event, context)
 
     mock_concurrency_controller_service.update_function_concurrency.assert_called_once_with(
         "test-lambda-function", 10
     )
 
-    assert result == expected_response
+    assert result["statusCode"] == 200
+    assert result["body"]["message"] == "Concurrency updated successfully"
+    assert result["body"]["function"] == "test-lambda-function"
+    assert result["body"]["reservedConcurrency"] == 10
 
 
 def test_lambda_handler_with_zero_concurrency(
     event_with_zero_concurrency, context, mock_concurrency_controller_service
 ):
-    expected_response = {
-        "statusCode": 200,
-        "body": {
-            "message": "Concurrency updated successfully",
-            "function": "test-lambda-function",
-            "reservedConcurrency": 0
-        }
-    }
-    
-    mock_concurrency_controller_service.update_function_concurrency.return_value = expected_response
+    mock_concurrency_controller_service.update_function_concurrency.return_value = 0
 
     result = lambda_handler(event_with_zero_concurrency, context)
 
     mock_concurrency_controller_service.update_function_concurrency.assert_called_once_with(
         "test-lambda-function", 0
     )
 
-    assert result == expected_response
+    assert result["statusCode"] == 200
+    assert result["body"]["message"] == "Concurrency updated successfully"
+    assert result["body"]["function"] == "test-lambda-function"
+    assert result["body"]["reservedConcurrency"] == 0
 
 
 def test_lambda_handler_with_large_concurrency(context, mock_concurrency_controller_service):
@@ -85,23 +73,23 @@ def test_lambda_handler_with_large_concurrency(context, mock_concurrency_control
         "reservedConcurrency": 1000
     }
 
-    expected_response = {
-        "statusCode": 200,
-        "body": {
-            "message": "Concurrency updated successfully",
-            "function": "test-lambda-function",
-            "reservedConcurrency": 1000
-        }
-    }
-    
-    mock_concurrency_controller_service.update_function_concurrency.return_value = expected_response
+    mock_concurrency_controller_service.update_function_concurrency.return_value = 1000
 
     result = lambda_handler(event, context)
 
     mock_concurrency_controller_service.update_function_concurrency.assert_called_once_with(
         "test-lambda-function", 1000
     )
 
+    assert result["statusCode"] == 200
+    assert result["body"]["message"] == "Concurrency updated successfully"
+    assert result["body"]["function"] == "test-lambda-function"
+    assert result["body"]["reservedConcurrency"] == 1000
+    
+    mock_concurrency_controller_service.update_function_concurrency.assert_called_once_with(
+        "test-lambda-function", 1000
+    )
+    
     assert result == expected_response
 
 

lambdas/tests/unit/services/test_concurrency_controller_service.py

@@ -39,10 +39,7 @@ def test_update_function_concurrency_success(service, mock_lambda_client, mock_l
         ReservedConcurrentExecutions=reserved_concurrency
     )
 
-    assert result["statusCode"] == 200
-    assert result["body"]["message"] == "Concurrency updated successfully"
-    assert result["body"]["function"] == target_function
-    assert result["body"]["reservedConcurrency"] == reserved_concurrency
+    assert result == reserved_concurrency
 
     mock_logger.info.assert_any_call(
         f"Updating reserved concurrency for function '{target_function}' to {reserved_concurrency}"
@@ -64,20 +61,11 @@ def test_update_function_concurrency_function_not_found(service, mock_lambda_cli
         'Error': {
             'Code': 'ResourceNotFoundException',
             'Message': 'Function not found'
-        }
+        },
+        'ResponseMetadata': {'HTTPStatusCode': 404}
     }
 
-    # Create proper exception classes that inherit from ClientError
-    resource_not_found_exception = type('ResourceNotFoundException', (ClientError,), {})
-    invalid_param_exception = type('InvalidParameterValueException', (ClientError,), {})
-    
-    # Create a mock exceptions object with both exception types
-    mock_exceptions = MagicMock()
-    mock_exceptions.ResourceNotFoundException = resource_not_found_exception
-    mock_exceptions.InvalidParameterValueException = invalid_param_exception
-    mock_client_instance.exceptions = mock_exceptions
-    
-    mock_client_instance.put_function_concurrency.side_effect = resource_not_found_exception(
+    mock_client_instance.put_function_concurrency.side_effect = ClientError(
         error_response, 'PutFunctionConcurrency'
     )
 
@@ -102,20 +90,11 @@ def test_update_function_concurrency_invalid_parameter(service, mock_lambda_clie
         'Error': {
             'Code': 'InvalidParameterValueException',
             'Message': 'Reserved concurrency value must be non-negative'
-        }
+        },
+        'ResponseMetadata': {'HTTPStatusCode': 400}
     }
 
-    # Create proper exception classes that inherit from ClientError
-    resource_not_found_exception = type('ResourceNotFoundException', (ClientError,), {})
-    invalid_param_exception = type('InvalidParameterValueException', (ClientError,), {})
-    
-    # Create a mock exceptions object with both exception types
-    mock_exceptions = MagicMock()
-    mock_exceptions.ResourceNotFoundException = resource_not_found_exception
-    mock_exceptions.InvalidParameterValueException = invalid_param_exception
-    mock_client_instance.exceptions = mock_exceptions
-    
-    mock_client_instance.put_function_concurrency.side_effect = invalid_param_exception(
+    mock_client_instance.put_function_concurrency.side_effect = ClientError(
         error_response, 'PutFunctionConcurrency'
     )
 
@@ -124,9 +103,9 @@ def test_update_function_concurrency_invalid_parameter(service, mock_lambda_clie
     with pytest.raises(ClientError):
         service.update_function_concurrency(target_function, reserved_concurrency)
 
-    assert mock_logger.error.call_count == 1
-    error_call_args = str(mock_logger.error.call_args)
-    assert "Invalid concurrency value" in error_call_args
+    mock_logger.error.assert_called_once_with(
+        f"Failed to update concurrency: An error occurred (InvalidParameterValueException) when calling the PutFunctionConcurrency operation: Reserved concurrency value must be non-negative"
+    )
 
 
 def test_update_function_concurrency_with_zero_value(service, mock_lambda_client, mock_logger):
@@ -144,8 +123,7 @@ def test_update_function_concurrency_with_zero_value(service, mock_lambda_client
 
     result = service.update_function_concurrency(target_function, reserved_concurrency)
 
-    assert result["statusCode"] == 200
-    assert result["body"]["reservedConcurrency"] == 0
+    assert result == 0
 
 
 def test_update_function_concurrency_with_large_value(service, mock_lambda_client, mock_logger):
@@ -163,12 +141,53 @@ def test_update_function_concurrency_with_large_value(service, mock_lambda_clien
 
     result = service.update_function_concurrency(target_function, reserved_concurrency)
 
-    assert result["statusCode"] == 200
-    assert result["body"]["reservedConcurrency"] == 1000
+    assert result == 1000
 
 
 def test_init_creates_lambda_client(mock_lambda_client):
     service = ConcurrencyControllerService()
 
     mock_lambda_client.assert_called_once_with("lambda")
     assert service.lambda_client is not None
+
+
+def test_update_function_concurrency_missing_response_field(service, mock_lambda_client, mock_logger):
+    target_function = "test-lambda-function"
+    reserved_concurrency = 10
+    
+    mock_client_instance = MagicMock()
+    mock_lambda_client.return_value = mock_client_instance
+    
+    # Response missing ReservedConcurrentExecutions field
+    mock_client_instance.put_function_concurrency.return_value = {}
+    
+    service.lambda_client = mock_client_instance
+    
+    with pytest.raises(ValueError) as exc_info:
+        service.update_function_concurrency(target_function, reserved_concurrency)
+    
+    assert str(exc_info.value) == "Failed to confirm concurrency update from AWS response"
+    mock_logger.error.assert_called_with("Response did not contain ReservedConcurrentExecutions")
+
+
+def test_update_function_concurrency_value_mismatch(service, mock_lambda_client, mock_logger):
+    target_function = "test-lambda-function"
+    reserved_concurrency = 10
+    
+    mock_client_instance = MagicMock()
+    mock_lambda_client.return_value = mock_client_instance
+    
+    # AWS returned different value than requested
+    mock_client_instance.put_function_concurrency.return_value = {
+        "ReservedConcurrentExecutions": 5
+    }
+    
+    service.lambda_client = mock_client_instance
+    
+    with pytest.raises(ValueError) as exc_info:
+        service.update_function_concurrency(target_function, reserved_concurrency)
+    
+    assert str(exc_info.value) == "Concurrency update verification failed"
+    mock_logger.error.assert_called_with(
+        f"Concurrency mismatch: requested {reserved_concurrency}, AWS returned 5"
+    )