Tests

Author: dandrejvv

Tests/AwsLambdaFunction.Sqs.GroupA/.gitignore

@@ -0,0 +1,4 @@
+# Intent Architect
+
+**/.intent/*
+!*.application.output.log

Tests/AwsLambdaFunction.Sqs.GroupA/AwsLambdaFunction.Sqs.GroupA.Api/AwsLambdaFunction.Sqs.GroupA.Api.csproj

@@ -0,0 +1,37 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <OutputType>Library</OutputType>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <NoWarn>$(NoWarn);1591</NoWarn>
+    <Nullable>enable</Nullable>
+    <AWSProjectType>Lambda</AWSProjectType>
+    <PublishReadyToRun>true</PublishReadyToRun>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\AwsLambdaFunction.Sqs.GroupA.Application\AwsLambdaFunction.Sqs.GroupA.Application.csproj" />
+    <ProjectReference Include="..\AwsLambdaFunction.Sqs.GroupA.Infrastructure\AwsLambdaFunction.Sqs.GroupA.Infrastructure.csproj" />
+  </ItemGroup>
+    <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+    <ItemGroup>
+      <PackageReference Include="Amazon.Lambda.Annotations" Version="1.7.0" />
+      <PackageReference Include="Amazon.Lambda.APIGatewayEvents" Version="2.7.1" />
+      <PackageReference Include="Amazon.Lambda.Core" Version="2.7.1" />
+      <PackageReference Include="Amazon.Lambda.Logging.AspNetCore" Version="4.1.1" />
+      <PackageReference Include="Amazon.Lambda.Serialization.SystemTextJson" Version="2.4.4" />
+    </ItemGroup>
+    <ItemGroup>
+    <Content Remove="appsettings.json" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="appsettings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+</Project>

Tests/AwsLambdaFunction.Sqs.GroupA/AwsLambdaFunction.Sqs.GroupA.Api/Configuration/ApplicationSecurityConfiguration.cs

@@ -0,0 +1,22 @@
+using AwsLambdaFunction.Sqs.GroupA.Api.Services;
+using AwsLambdaFunction.Sqs.GroupA.Application.Common.Interfaces;
+using Intent.RoslynWeaver.Attributes;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+[assembly: DefaultIntentManaged(Mode.Fully)]
+[assembly: IntentTemplate("Intent.Application.Identity.ApplicationSecurityConfiguration", Version = "1.0")]
+
+namespace AwsLambdaFunction.Sqs.GroupA.Api.Configuration
+{
+    public static class ApplicationSecurityConfiguration
+    {
+        public static IServiceCollection ConfigureApplicationSecurity(
+            this IServiceCollection services,
+            IConfiguration configuration)
+        {
+            services.AddSingleton<ICurrentUserService, CurrentUserService>();
+            return services;
+        }
+    }
+}

Tests/AwsLambdaFunction.Sqs.GroupA/AwsLambdaFunction.Sqs.GroupA.Api/DefaultFunctions.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Amazon.Lambda.Annotations;
+using Amazon.Lambda.Annotations.APIGateway;
+using Amazon.Lambda.Core;
+using AwsLambdaFunction.Sqs.GroupA.Api.Helpers;
+using AwsLambdaFunction.Sqs.GroupA.Application.CreateClient;
+using AwsLambdaFunction.Sqs.GroupA.Application.CreateOrder;
+using Intent.RoslynWeaver.Attributes;
+using MediatR;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+[assembly: DefaultIntentManaged(Mode.Fully)]
+[assembly: IntentTemplate("Intent.Aws.Lambda.Functions.LambdaFunctionClassTemplate", Version = "1.0")]
+
+namespace AwsLambdaFunction.Sqs.GroupA.Api
+{
+    public class DefaultFunctions
+    {
+        private readonly ILogger<DefaultFunctions> _logger;
+        private readonly ISender _mediator;
+
+        public DefaultFunctions(ILogger<DefaultFunctions> logger, ISender mediator)
+        {
+            _logger = logger;
+            _mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
+        }
+
+        [LambdaFunction]
+        [HttpApi(LambdaHttpMethod.Post, "/api/client")]
+        public async Task<IHttpResult> CreateClientAsync([FromBody] CreateClientCommand command)
+        {
+            // AWSLambda0107: can parameter of type System.Threading.CancellationToken passing is not supported.
+            var cancellationToken = CancellationToken.None;
+            return await ExceptionHandlerHelper.ExecuteAsync(async () =>
+            {
+                await _mediator.Send(command, cancellationToken);
+                return HttpResults.Created();
+            }, _logger);
+        }
+
+        [LambdaFunction]
+        [HttpApi(LambdaHttpMethod.Post, "/api/order")]
+        public async Task<IHttpResult> CreateOrderAsync([FromBody] CreateOrderCommand command)
+        {
+            // AWSLambda0107: can parameter of type System.Threading.CancellationToken passing is not supported.
+            var cancellationToken = CancellationToken.None;
+            return await ExceptionHandlerHelper.ExecuteAsync(async () =>
+            {
+                await _mediator.Send(command, cancellationToken);
+                return HttpResults.Created();
+            }, _logger);
+        }
+    }
+}

Tests/AwsLambdaFunction.Sqs.GroupA/AwsLambdaFunction.Sqs.GroupA.Api/Helpers/ExceptionHandlerHelper.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Threading.Tasks;
+using Amazon.Lambda.Annotations.APIGateway;
+using AwsLambdaFunction.Sqs.GroupA.Application.Common.Exceptions;
+using FluentValidation;
+using Intent.RoslynWeaver.Attributes;
+using Microsoft.Extensions.Logging;
+
+[assembly: DefaultIntentManaged(Mode.Fully)]
+[assembly: IntentTemplate("Intent.Aws.Lambda.Functions.ExceptionHandlerHelper", Version = "1.0")]
+
+namespace AwsLambdaFunction.Sqs.GroupA.Api.Helpers
+{
+    public static class ExceptionHandlerHelper
+    {
+        public static async Task<IHttpResult> ExecuteAsync(Func<Task<IHttpResult>> operation, ILogger logger)
+        {
+            try
+            {
+                return await operation();
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Unhandled exception occurred: {Message}", ex.Message);
+                return HandleException(ex);
+            }
+        }
+
+        private static IHttpResult HandleException(Exception exception)
+        {
+            switch (exception)
+            {
+                case ValidationException validationEx:
+                    var errors = new List<ValidationError>();
+
+                    foreach (var error in validationEx.Errors)
+                    {
+                        errors.Add(new ValidationError(error.PropertyName, error.ErrorMessage, error.ErrorCode));
+                    }
+                    return HttpResults.BadRequest(new ResponseErrors("ValidationError", "One or more validation errors occurred", 400, errors));
+                case ForbiddenAccessException forbiddenEx:
+                    return HttpResults.NewResult(HttpStatusCode.Forbidden, new ResponseDetail("Forbidden", "Access forbidden", 403, forbiddenEx.Message ?? "You do not have permission to access this resource"));
+                case UnauthorizedAccessException unauthorizedEx:
+                    return HttpResults.NewResult(HttpStatusCode.Unauthorized, new ResponseDetail("Unauthorized", "Authentication required", 401, unauthorizedEx.Message ?? "Authentication is required to access this resource"));
+                default:
+                    return HttpResults.NewResult(HttpStatusCode.InternalServerError, new ResponseDetail("InternalServerError", "An error occurred while processing your request", 500, "Please try again later or contact support if the problem persists"));
+            }
+        }
+
+        private record ResponseDetail(string Type, string Title, int Status, object Detail);
+
+        private record ResponseErrors(string Type, string Title, int Status, List<ValidationError> Errors);
+
+        private record ValidationError(string Property, string Message, string Code);
+
+    }
+}

Tests/AwsLambdaFunction.Sqs.GroupA/AwsLambdaFunction.Sqs.GroupA.Api/Properties/launchSettings.json

@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "Mock Lambda Test Tool": {
+      "commandName": "Executable",
+      "launchBrowser": false,
+      "commandLineArgs": "--port 5050",
+      "executablePath": "%USERPROFILE%\\.dotnet\\tools\\dotnet-lambda-test-tool-8.0.exe",
+      "publishAllPorts": false,
+      "workingDirectory": "$(ProjectDir)$(OutputPath)"
+    }
+  }
+}

Tests/AwsLambdaFunction.Sqs.GroupA/AwsLambdaFunction.Sqs.GroupA.Api/README.md

@@ -0,0 +1,51 @@
+### Overview
+
+This is a .NET AWS Lambda project that leverages the **Amazon.Lambda.Annotations** framework to streamline the creation of serverless functions. This approach allows for idiomatic C# coding patterns, with boilerplate code and CloudFormation templates generated automatically at compile time using C# source generators. The project is configured to use **Amazon.Lambda.Logging.AspNetCore** for CloudWatch logging and can be configured through both **`appsettings.json`** and environment variables.
+
+*** 
+
+### Local Development and Debugging
+
+You have two primary options for local development and debugging:
+
+#### 1. Running the Mock Lambda Test Tool
+
+The project is configured to launch the **`dotnet-lambda-test-tool-8.0.exe`** from a launch profile in the **`launchSettings.json`** file. This tool provides a local host for running and testing your Lambda functions. The tool allows you to manually invoke your functions with different event payloads, which is useful for rapid, isolated testing.
+
+#### 2. Using the SAM CLI
+
+For a more comprehensive local emulation of the AWS environment, you can use the **AWS SAM CLI**. This is particularly useful for testing how your functions integrate with other AWS services, such as API Gateway.
+
+1. **Install AWS CLI**: If you don't have it, follow the instructions on [Installing or updating to the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+2. **Install AWS SAM CLI**: Follow the instructions on [Installing the AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html).
+3. **Build Project**: From the project directory, run the command **`sam build --template serverless.template`**. This will compile your application and prepare it for local execution.
+4. **Start the Local API**: From the project directory, run the command **`sam local start-api`**. This will launch a local API Gateway endpoint that routes requests to your Lambda functions, as defined in the CloudFormation template.
+
+***
+
+### Configuration
+
+Application configuration is handled using a standard .NET configuration provider, which reads from **`appsettings.json`** and environment variables. Environment variables take precedence over settings in the `appsettings.json` file, allowing you to easily manage different configurations for various environments (e.g., development, staging, production) without changing code.
+
+***
+
+### Deployment
+
+To deploy the application to AWS, you'll use the **Amazon.Lambda.Tools** global tool.
+
+1.  **Prerequisites**: 
+    - If you don't have an AWS account, register at [AWS Console](https://aws.amazon.com/console/).
+    - Ensure you have an IAM user with appropriate permissions and a configured AWS credentials file at `~/.aws/credentials`.
+2.  **Install the Deployment Tool**: If not already installed, run `dotnet tool install --global Amazon.Lambda.Tools`.
+3.  **Deploy**: From your project directory, execute the command **`dotnet lambda deploy-serverless`**. This command will package your application and deploy it to AWS as a CloudFormation stack.
+
+***
+
+### Resources
+
+* **AWS Lambda Annotations GitHub Repository**: The official source code and detailed documentation for the framework.
+    * [https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.Annotations/README.md](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.Annotations/README.md)
+* **AWS Extensions for .NET CLI**: Documentation for the deployment tools.
+    * [https://github.com/aws/aws-extensions-for-dotnet-cli](https://github.com/aws/aws-extensions-for-dotnet-cli)
+* **AWS Lambda for .NET**: The main GitHub repository for the AWS .NET Lambda tools.
+    * [https://github.com/aws/aws-lambda-dotnet](https://github.com/aws/aws-lambda-dotnet)

Tests/AwsLambdaFunction.Sqs.GroupA/AwsLambdaFunction.Sqs.GroupA.Api/ResponseTypes/JsonResponse.cs

@@ -0,0 +1,21 @@
+using Intent.RoslynWeaver.Attributes;
+
+[assembly: DefaultIntentManaged(Mode.Fully)]
+[assembly: IntentTemplate("Intent.Aws.Lambda.Functions.JsonResponse", Version = "1.0")]
+
+namespace AwsLambdaFunction.Sqs.GroupA.Api.ResponseTypes
+{
+    /// <summary>
+    /// Implicit wrapping of types that serialize to non-complex values.
+    /// </summary>
+    /// <typeparam name="T">Types such as string, Guid, int, long, etc.</typeparam>
+    public class JsonResponse<T>
+    {
+        public JsonResponse(T value)
+        {
+            Value = value;
+        }
+
+        public T Value { get; set; }
+    }
+}

Tests/AwsLambdaFunction.Sqs.GroupA/AwsLambdaFunction.Sqs.GroupA.Api/Services/CurrentUserService.cs

@@ -0,0 +1,31 @@
+using System.Threading.Tasks;
+using AwsLambdaFunction.Sqs.GroupA.Application.Common.Interfaces;
+using Intent.RoslynWeaver.Attributes;
+
+[assembly: DefaultIntentManaged(Mode.Fully)]
+[assembly: IntentTemplate("Intent.Application.Identity.CurrentUserService", Version = "1.0")]
+
+namespace AwsLambdaFunction.Sqs.GroupA.Api.Services
+{
+    public class CurrentUserService : ICurrentUserService
+    {
+        public CurrentUserService()
+        {
+        }
+
+        public Task<ICurrentUser?> GetAsync()
+        {
+            return Task.FromResult<ICurrentUser?>(null);
+        }
+
+        public async Task<bool> AuthorizeAsync(string policy)
+        {
+            return await Task.FromResult(true);
+        }
+
+        public async Task<bool> IsInRoleAsync(string role)
+        {
+            return await Task.FromResult(true);
+        }
+    }
+}

Tests/AwsLambdaFunction.Sqs.GroupA/AwsLambdaFunction.Sqs.GroupA.Api/SpecificTopicMessageConsumer.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Amazon.Lambda.Annotations;
+using Amazon.Lambda.Core;
+using Amazon.Lambda.SQSEvents;
+using AwsLambdaFunction.Sqs.GroupA.Application.Common.Eventing;
+using AwsLambdaFunction.Sqs.GroupA.Infrastructure.Eventing;
+using Intent.RoslynWeaver.Attributes;
+using Microsoft.Extensions.Logging;
+
+[assembly: DefaultIntentManaged(Mode.Fully)]
+[assembly: IntentTemplate("Intent.Aws.Lambda.Functions.Sqs.LambdaFunctionConsumer", Version = "1.0")]
+
+namespace AwsLambdaFunction.Sqs.GroupA.Api
+{
+    public class SpecificTopicMessageConsumer
+    {
+        private readonly ILogger<SpecificTopicMessageConsumer> _logger;
+        private readonly ISqsMessageDispatcher _dispatcher;
+        private readonly IEventBus _eventBus;
+        private readonly IServiceProvider _serviceProvider;
+
+        public SpecificTopicMessageConsumer(ILogger<SpecificTopicMessageConsumer> logger,
+            ISqsMessageDispatcher dispatcher,
+            IEventBus eventBus,
+            IServiceProvider serviceProvider)
+        {
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
+            _eventBus = eventBus ?? throw new ArgumentNullException(nameof(eventBus));
+            _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
+        }
+
+        [LambdaFunction]
+        public async Task ProcessAsync(SQSEvent sqsEvent, ILambdaContext context)
+        {
+            // AWSLambda0107: passing CancellationToken parameters is not supported; use CancellationToken.None instead.
+            var cancellationToken = CancellationToken.None;
+
+            foreach (var record in sqsEvent.Records)
+            {
+                try
+                {
+                    await _dispatcher.DispatchAsync(_serviceProvider, record, cancellationToken);
+                    await _eventBus.FlushAllAsync(cancellationToken);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error processing SpecificTopicMessageConsumer message with ID {MessageId}", record.MessageId);
+                    throw;
+                }
+            }
+        }
+    }
+}