[HttpApi(LambdaHttpMethod.Get, "/add/{x}/{y}")] responding to POST

[genifycom]

Describe the bug

Using the default project, the method annotated with [HttpApi(LambdaHttpMethod.Get, "/add/{x}/{y}")] is getting called when the API Gateway V2 HTTP API says "http": {
"method": "POST",
...}

Expected Behavior

The annotation LambdaHttpMethod.Get should only respond to a GET

Current Behavior

A debug breakpoint in the default annotations project was called with the Mock Lambda Test Tool and Example Request of API Gateway V2 HTTP API.

Noticed that the breakpoint was triggered when the V2 payload was for a POST.

Reproduction Steps

See current behavior

Possible Solution

No response

Additional Information/Context

No response

AWS .NET SDK and/or Package version used

Amazon.Lambda.Annotations 0.13.2
Amazon.Lambda.APIGatewayEven 2.6.0
Amazon.Lambda.Core 2.1.0
Amazon.Lambda.Serialization 2.3.1

Targeted .NET Platform

.NET 6

Operating System and version

Windows 11

[ashishdhingra]

Hi @genifycom,

Good afternoon.

Thanks for reporting the issue. I'm not sure if Lambda Test Tool works well with Annotations framework. In Visual Studio, if you look at the generated code for the project, following files are generated:

• Functions_Add_Generated.g.cs
• Functions_Default_Generated.g.cs
• Functions_Divide_Generated.g.cs
• Functions_Multiply_Generated.g.cs
• Functions_Substract_Generated.g.cs

All the files at high level, generated the below code (taking Functions_Add_Generated.g.cs as an example):

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;
using Microsoft.Extensions.DependencyInjection;
using Amazon.Lambda.Core;

namespace LambdaAnnotationsTest
{
    public class Functions_Add_Generated
    {
        private readonly ServiceProvider serviceProvider;

        public Functions_Add_Generated()
        {
            SetExecutionEnvironment();
            var services = new ServiceCollection();

            // By default, Lambda function class is added to the service container using the singleton lifetime
            // To use a different lifetime, specify the lifetime in Startup.ConfigureServices(IServiceCollection) method.
            services.AddSingleton<Functions>();

            var startup = new LambdaAnnotationsTest.Startup();
            startup.ConfigureServices(services);
            serviceProvider = services.BuildServiceProvider();
        }

        public Amazon.Lambda.APIGatewayEvents.APIGatewayHttpApiV2ProxyResponse Add(Amazon.Lambda.APIGatewayEvents.APIGatewayHttpApiV2ProxyRequest request, Amazon.Lambda.Core.ILambdaContext context)
        {
            // Create a scope for every request,
            // this allows creating scoped dependencies without creating a scope manually.
            using var scope = serviceProvider.CreateScope();
            var functions = scope.ServiceProvider.GetRequiredService<Functions>();

            var validationErrors = new List<string>();

            var x = default(int);
            if (request.PathParameters?.ContainsKey("x") == true)
            {
                try
                {
                    x = (int)Convert.ChangeType(request.PathParameters["x"], typeof(int));
                }
                catch (Exception e) when (e is InvalidCastException || e is FormatException || e is OverflowException || e is ArgumentException)
                {
                    validationErrors.Add($"Value {request.PathParameters["x"]} at 'x' failed to satisfy constraint: {e.Message}");
                }
            }

            var y = default(int);
            if (request.PathParameters?.ContainsKey("y") == true)
            {
                try
                {
                    y = (int)Convert.ChangeType(request.PathParameters["y"], typeof(int));
                }
                catch (Exception e) when (e is InvalidCastException || e is FormatException || e is OverflowException || e is ArgumentException)
                {
                    validationErrors.Add($"Value {request.PathParameters["y"]} at 'y' failed to satisfy constraint: {e.Message}");
                }
            }

            // return 400 Bad Request if there exists a validation error
            if (validationErrors.Any())
            {
                return new Amazon.Lambda.APIGatewayEvents.APIGatewayHttpApiV2ProxyResponse
                {
                    Body = @$"{{""message"": ""{validationErrors.Count} validation error(s) detected: {string.Join(",", validationErrors)}""}}",
                    Headers = new Dictionary<string, string>
                    {
                        {"Content-Type", "application/json"},
                        {"x-amzn-ErrorType", "ValidationException"}
                    },
                    StatusCode = 400
                };
            }

            var response = functions.Add(x, y, context);

            var body = response.ToString();

            return new Amazon.Lambda.APIGatewayEvents.APIGatewayHttpApiV2ProxyResponse
            {
                Body = body,
                Headers = new Dictionary<string, string>
                {
                    {"Content-Type", "application/json"}
                },
                StatusCode = 200
            };
        }

        private static void SetExecutionEnvironment()
        {
            const string envName = "AWS_EXECUTION_ENV";

            var envValue = new StringBuilder();

            // If there is an existing execution environment variable add the annotations package as a suffix.
            if(!string.IsNullOrEmpty(Environment.GetEnvironmentVariable(envName)))
            {
                envValue.Append($"{Environment.GetEnvironmentVariable(envName)}_");
            }

            envValue.Append("amazon-lambda-annotations_0.5.0.0");

            Environment.SetEnvironmentVariable(envName, envValue.ToString());
        }
    }
}

with the difference in generated public method name (e.g. Add, Divide, Multiply, etc.).

So, my assumption is that when the request is executed from the Lambda Test tool, it is mapping with the first in alphabetical order from the list of generated methods, which is Add in default case. For instance, if I comment out Functions.Add(), it executes Default() method.

With respect to bug, the attribute HttpApi(LambdaHttpMethod.Get) is used during deployment (publish) while generating the CloudFormation template (serverless.template). Below is the one generated in my scenario:

{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Transform": "AWS::Serverless-2016-10-31",
  "Description": "An AWS Serverless Application.",
  "Resources": {
    "LambdaAnnotationsTestFunctionsDefaultGenerated": {
      "Type": "AWS::Serverless::Function",
      "Metadata": {
        "Tool": "Amazon.Lambda.Annotations",
        "SyncedEvents": [
          "RootGet"
        ]
      },
      "Properties": {
        "Runtime": "dotnet6",
        "CodeUri": ".",
        "MemorySize": 256,
        "Timeout": 30,
        "Policies": [
          "AWSLambdaBasicExecutionRole"
        ],
        "PackageType": "Zip",
        "Handler": "LambdaAnnotationsTest::LambdaAnnotationsTest.Functions_Default_Generated::Default",
        "Events": {
          "RootGet": {
            "Type": "HttpApi",
            "Properties": {
              "Path": "/",
              "Method": "GET",
              "PayloadFormatVersion": "2.0"
            }
          }
        }
      }
    },
    "LambdaAnnotationsTestFunctionsSubstractGenerated": {
      "Type": "AWS::Serverless::Function",
      "Metadata": {
        "Tool": "Amazon.Lambda.Annotations",
        "SyncedEvents": [
          "RootGet"
        ]
      },
      "Properties": {
        "Runtime": "dotnet6",
        "CodeUri": ".",
        "MemorySize": 256,
        "Timeout": 30,
        "Policies": [
          "AWSLambdaBasicExecutionRole"
        ],
        "PackageType": "Zip",
        "Handler": "LambdaAnnotationsTest::LambdaAnnotationsTest.Functions_Substract_Generated::Substract",
        "Events": {
          "RootGet": {
            "Type": "HttpApi",
            "Properties": {
              "Path": "/substract/{x}/{y}",
              "Method": "GET",
              "PayloadFormatVersion": "2.0"
            }
          }
        }
      }
    },
    "LambdaAnnotationsTestFunctionsMultiplyGenerated": {
      "Type": "AWS::Serverless::Function",
      "Metadata": {
        "Tool": "Amazon.Lambda.Annotations",
        "SyncedEvents": [
          "RootGet"
        ]
      },
      "Properties": {
        "Runtime": "dotnet6",
        "CodeUri": ".",
        "MemorySize": 256,
        "Timeout": 30,
        "Policies": [
          "AWSLambdaBasicExecutionRole"
        ],
        "PackageType": "Zip",
        "Handler": "LambdaAnnotationsTest::LambdaAnnotationsTest.Functions_Multiply_Generated::Multiply",
        "Events": {
          "RootGet": {
            "Type": "HttpApi",
            "Properties": {
              "Path": "/multiply/{x}/{y}",
              "Method": "GET",
              "PayloadFormatVersion": "2.0"
            }
          }
        }
      }
    },
    "LambdaAnnotationsTestFunctionsDivideGenerated": {
      "Type": "AWS::Serverless::Function",
      "Metadata": {
        "Tool": "Amazon.Lambda.Annotations",
        "SyncedEvents": [
          "RootGet"
        ]
      },
      "Properties": {
        "Runtime": "dotnet6",
        "CodeUri": ".",
        "MemorySize": 256,
        "Timeout": 30,
        "Policies": [
          "AWSLambdaBasicExecutionRole"
        ],
        "PackageType": "Zip",
        "Handler": "LambdaAnnotationsTest::LambdaAnnotationsTest.Functions_Divide_Generated::Divide",
        "Events": {
          "RootGet": {
            "Type": "HttpApi",
            "Properties": {
              "Path": "/divide/{x}/{y}",
              "Method": "GET",
              "PayloadFormatVersion": "2.0"
            }
          }
        }
      }
    },
    "LambdaAnnotationsTestFunctionsAddGenerated": {
      "Type": "AWS::Serverless::Function",
      "Metadata": {
        "Tool": "Amazon.Lambda.Annotations",
        "SyncedEvents": [
          "RootGet"
        ]
      },
      "Properties": {
        "Runtime": "dotnet6",
        "CodeUri": ".",
        "MemorySize": 256,
        "Timeout": 30,
        "Policies": [
          "AWSLambdaBasicExecutionRole"
        ],
        "PackageType": "Zip",
        "Handler": "LambdaAnnotationsTest::LambdaAnnotationsTest.Functions_Add_Generated::Add",
        "Events": {
          "RootGet": {
            "Type": "HttpApi",
            "Properties": {
              "Path": "/add/{x}/{y}",
              "Method": "GET",
              "PayloadFormatVersion": "2.0"
            }
          }
        }
      }
    }
  },
  "Outputs": {
    "ApiURL": {
      "Description": "API endpoint URL for Prod environment",
      "Value": {
        "Fn::Sub": "https://${ServerlessHttpApi}.execute-api.${AWS::Region}.amazonaws.com/"
      }
    }
  }
}

The attribute handling and above findings on generated classes, is also documented in Lambda Annotations Readme.

The Lambda Test Tool is just a simple tool used to test Lambda functions locally with example requests in the drop down. It simulates handling the Lambda requests end-to-end to some extent, but it doesn't simulate the actual API Gateway deployed environment. This has not changed since annotations was released and the behavior is consistent with the Serverless Web API template.

Thanks,
Ashish

[normj]

@genifycom functions created by the Annotations library work just like "regular" Lambda functions. The mock test tool always takes whatever is in the input window and sends it to the function that is listed in the functions drop down box. It is simulating a Lambda invoke not API Gateway routing. Although we have talked about adding such a feature for a long time we haven't been able to prioritize that.

[github-actions]

This issue has not received a response in 5 days. If you want to keep this issue open, please just leave a comment below and auto-close will be canceled.