feat: implement Lambda invocation with error handling

- Add parameter validation and comprehensive error handling for all exception types
- Implement status code validation and function error detection
- Add ResourceNotFoundException and InvalidParameterValueException handling
- Include test coverage for all error paths and edge cases
- Support synchronous Lambda invocation with proper payload serialization and response parsing

Author: Rares Polenciuc

src/aws_durable_execution_sdk_python_testing/invoker.py

@@ -8,15 +8,14 @@
     DurableExecutionInvocationInput,
     DurableExecutionInvocationInputWithClient,
     DurableExecutionInvocationOutput,
-    InitialExecutionState,
+    InitialExecutionState, InvocationStatus,
 )
 
 from aws_durable_execution_sdk_python_testing.exceptions import (
     DurableFunctionsTestError,
 )
 from aws_durable_execution_sdk_python_testing.model import LambdaContext
 
-
 if TYPE_CHECKING:
     from collections.abc import Callable
 
@@ -55,17 +54,17 @@ def create_test_lambda_context() -> LambdaContext:
 
 class Invoker(Protocol):
     def create_invocation_input(
-        self, execution: Execution
+            self, execution: Execution
     ) -> DurableExecutionInvocationInput: ...  # pragma: no cover
 
     def invoke(
-        self,
-        function_name: str,
-        input: DurableExecutionInvocationInput,
+            self,
+            function_name: str,
+            input: DurableExecutionInvocationInput,
     ) -> DurableExecutionInvocationOutput: ...  # pragma: no cover
 
     def update_endpoint(
-        self, endpoint_url: str, region_name: str
+            self, endpoint_url: str, region_name: str
     ) -> None: ...  # pragma: no cover
 
 
@@ -75,7 +74,7 @@ def __init__(self, handler: Callable, service_client: InMemoryServiceClient):
         self.service_client = service_client
 
     def create_invocation_input(
-        self, execution: Execution
+            self, execution: Execution
     ) -> DurableExecutionInvocationInput:
         return DurableExecutionInvocationInputWithClient(
             durable_execution_arn=execution.durable_execution_arn,
@@ -90,9 +89,9 @@ def create_invocation_input(
         )
 
     def invoke(
-        self,
-        function_name: str,  # noqa: ARG002
-        input: DurableExecutionInvocationInput,
+            self,
+            function_name: str,  # noqa: ARG002
+            input: DurableExecutionInvocationInput,
     ) -> DurableExecutionInvocationOutput:
         # TODO: reasses if function_name will be used in future
         input_with_client = DurableExecutionInvocationInputWithClient.from_durable_execution_invocation_input(
@@ -126,7 +125,7 @@ def update_endpoint(self, endpoint_url: str, region_name: str) -> None:
         )
 
     def create_invocation_input(
-        self, execution: Execution
+            self, execution: Execution
     ) -> DurableExecutionInvocationInput:
         return DurableExecutionInvocationInput(
             durable_execution_arn=execution.durable_execution_arn,
@@ -139,21 +138,111 @@ def create_invocation_input(
         )
 
     def invoke(
-        self,
-        function_name: str,
-        input: DurableExecutionInvocationInput,
+            self,
+            function_name: str,
+            input: DurableExecutionInvocationInput,
     ) -> DurableExecutionInvocationOutput:
-        # TODO: wrap ResourceNotFoundException from lambda in ResourceNotFoundException from this lib
-        response = self.lambda_client.invoke(
-            FunctionName=function_name,
-            InvocationType="RequestResponse",  # Synchronous invocation
-            Payload=json.dumps(input.to_dict(), default=str),
+        """Invoke AWS Lambda function and return durable execution result.
+
+        Args:
+            function_name: Name of the Lambda function to invoke
+            input: Durable execution invocation input
+
+        Returns:
+            DurableExecutionInvocationOutput: Result of the function execution
+
+        Raises:
+            ResourceNotFoundException: If function does not exist
+            InvalidParameterValueException: If parameters are invalid
+            DurableFunctionsTestError: For other invocation failures
+        """
+        from aws_durable_execution_sdk_python_testing.exceptions import (
+            ResourceNotFoundException,
+            InvalidParameterValueException,
         )
 
-        # very simplified placeholder lol
-        if response["StatusCode"] == 200:  # noqa: PLR2004
-            json_response = json.loads(response["Payload"].read().decode("utf-8"))
-            return DurableExecutionInvocationOutput.from_dict(json_response)
+        # Parameter validation
+        if not function_name or not function_name.strip():
+            msg = "Function name is required"
+            raise InvalidParameterValueException(msg)
+
+        try:
+            # Invoke AWS Lambda function using standard invoke method
+            response = self.lambda_client.invoke(
+                FunctionName=function_name,
+                InvocationType="RequestResponse",  # Synchronous invocation
+                Payload=json.dumps(input.to_dict(), default=str),
+            )
 
-        msg: str = f"Lambda invocation failed with status code: {response['StatusCode']}, {response['Payload']=}"
-        raise DurableFunctionsTestError(msg)
+            # Check HTTP status code
+            status_code = response.get("StatusCode")
+            if status_code not in (200, 202, 204):
+                msg = f"Lambda invocation failed with status code: {status_code}"
+                raise DurableFunctionsTestError(msg)
+
+            # Check for function errors
+            if "FunctionError" in response:
+                error_payload = response["Payload"].read().decode("utf-8")
+                msg = f"Lambda invocation failed with status {status_code}: {error_payload}"
+                raise DurableFunctionsTestError(msg)
+
+            # Parse response payload
+            response_payload = response["Payload"].read().decode("utf-8")
+            response_dict = json.loads(response_payload)
+
+            # Convert to DurableExecutionInvocationOutput
+            return DurableExecutionInvocationOutput.from_dict(response_dict)
+
+        except self.lambda_client.exceptions.ResourceNotFoundException as e:
+            msg = f"Function not found: {function_name}"
+            raise ResourceNotFoundException(msg) from e
+        except self.lambda_client.exceptions.InvalidParameterValueException as e:
+            msg = f"Invalid parameter: {e}"
+            raise InvalidParameterValueException(msg) from e
+        except (
+                self.lambda_client.exceptions.TooManyRequestsException,
+                self.lambda_client.exceptions.ServiceException,
+                self.lambda_client.exceptions.ResourceConflictException,
+                self.lambda_client.exceptions.InvalidRequestContentException,
+                self.lambda_client.exceptions.RequestTooLargeException,
+                self.lambda_client.exceptions.UnsupportedMediaTypeException,
+                self.lambda_client.exceptions.InvalidRuntimeException,
+                self.lambda_client.exceptions.InvalidZipFileException,
+                self.lambda_client.exceptions.ResourceNotReadyException,
+                self.lambda_client.exceptions.SnapStartTimeoutException,
+                self.lambda_client.exceptions.SnapStartNotReadyException,
+                self.lambda_client.exceptions.SnapStartException,
+                self.lambda_client.exceptions.RecursiveInvocationException,
+        ) as e:
+            msg = f"Lambda invocation failed: {e}"
+            raise DurableFunctionsTestError(msg) from e
+        except (
+                self.lambda_client.exceptions.InvalidSecurityGroupIDException,
+                self.lambda_client.exceptions.EC2ThrottledException,
+                self.lambda_client.exceptions.EFSMountConnectivityException,
+                self.lambda_client.exceptions.SubnetIPAddressLimitReachedException,
+                self.lambda_client.exceptions.EC2UnexpectedException,
+                self.lambda_client.exceptions.InvalidSubnetIDException,
+                self.lambda_client.exceptions.EC2AccessDeniedException,
+                self.lambda_client.exceptions.EFSIOException,
+                self.lambda_client.exceptions.ENILimitReachedException,
+                self.lambda_client.exceptions.EFSMountTimeoutException,
+                self.lambda_client.exceptions.EFSMountFailureException,
+        ) as e:
+            msg = f"Lambda infrastructure error: {e}"
+            raise DurableFunctionsTestError(msg) from e
+        except (
+                self.lambda_client.exceptions.KMSAccessDeniedException,
+                self.lambda_client.exceptions.KMSDisabledException,
+                self.lambda_client.exceptions.KMSNotFoundException,
+                self.lambda_client.exceptions.KMSInvalidStateException,
+        ) as e:
+            msg = f"Lambda KMS error: {e}"
+            raise DurableFunctionsTestError(msg) from e
+        except Exception as e:
+            # Handle any remaining exceptions, including custom ones like DurableExecutionAlreadyStartedException
+            if "DurableExecutionAlreadyStartedException" in str(type(e)):
+                msg = f"Durable execution already started: {e}"
+                raise DurableFunctionsTestError(msg) from e
+            msg = f"Unexpected error during Lambda invocation: {e}"
+            raise DurableFunctionsTestError(msg) from e