feat(testing): update server implementation and enhance testing infrastructure

.github/workflows/update-changelog.yaml

@@ -33,7 +33,7 @@ jobs:
         run: perl -i -pe 'BEGIN{undef $/} s/(## (?:\[)?v[\d.]+(?:\](?:\([^)]+\))?)? - \d{4}-\d{2}-\d{2}\n)[\s\S]*?### Changes\n+/$1\n/g' CHANGELOG.md
 
       - name: Create Pull Request
-        id: cpr
+        id: cpr 
         uses: peter-evans/create-pull-request@v7
         with:
           branch: changelog/${{ github.event.release.tag_name }}
@@ -48,7 +48,6 @@ jobs:
           commit-message: "chore: update changelog for ${{ github.event.release.tag_name }}"
           labels: "automated,changelog,chore"
           delete-branch: true
-          sign-commits: true
 
       - name: Enable Auto-merge
         if: steps.cpr.outputs.pull-request-number

CHANGELOG.md

@@ -3,7 +3,38 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [Unreleased](https://github.com/j-d-ha/aws-lambda-host/compare/v1.2.1...HEAD)
+## [Unreleased](https://github.com/j-d-ha/aws-lambda-host/compare/v1.3.1...HEAD)
+
+## [v1.3.1](https://github.com/j-d-ha/aws-lambda-host/compare/v1.3.0...v1.3.1) - 2025-12-10
+
+### 🐛 Bug Fixes
+
+* fix(core): add missing TenantId and TraceId properties to DefaultLambdaHostContext (#224) @j-d-ha
+* fix(ci): remove sign-commits from changelog workflow (#223) @j-d-ha
+
+## [v1.3.0](https://github.com/j-d-ha/aws-lambda-host/compare/v1.2.1...v1.3.0) - 2025-12-10
+
+## 🚀 Features
+
+* feat(source-generators): support multiple MapHandler invocations with custom feature providers (#214) @j-d-ha
+* docs: update MkDocs palette toggle configuration (#211) @j-d-ha
+
+## 🐛 Bug Fixes
+
+* fix: update third-party license attributions (#217) @j-d-ha
+
+## 📚 Documentation
+
+* docs: add comprehensive getting started guide and restructure documentation (#209) @j-d-ha
+
+## 🔄 Refactoring
+
+* refactor(host): migrate BootstrapHttpClient from options to dependency injection (#219) @j-d-ha
+* refactor(docs): replace ASPNETCORE_ENVIRONMENT with DOTNET_ENVIRONMENT (#216) @j-d-ha
+
+## 🔧 Maintenance
+
+* ci(github): optimize workflow triggers for draft PRs (#215) @j-d-ha
 
 ## [v1.2.1](https://github.com/j-d-ha/aws-lambda-host/compare/v1.2.0...v1.2.1) - 2025-11-30
 

examples/AwsLambda.Host.Example.Testing/Lambda/Program.cs

@@ -1,4 +1,5 @@
 using AwsLambda.Host.Builder;
+using AwsLambda.Host.Core;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 
@@ -13,8 +14,30 @@
 // Build the Lambda application
 var lambda = builder.Build();
 
+// throw new Exception("Init failed");
+
+// lambda.OnInit(() =>
+// {
+//     // throw new Exception("Init failed");
+//     // return false;
+// });
+
 // Map your handler - the event is automatically injected
-lambda.MapHandler(([Event] string name) => $"Hello {name}!");
+lambda.MapHandler(
+    async ([Event] string name, ILambdaHostContext context, CancellationToken cancellationToken) =>
+    {
+        await Task.Delay(TimeSpan.FromSeconds(60), cancellationToken);
+        if (string.IsNullOrWhiteSpace(name))
+            throw new ArgumentNullException(nameof(name), "Name is required.");
+
+        return $"Hello {name}!";
+    }
+);
+
+lambda.OnShutdown(() =>
+{
+    Console.WriteLine("Shutdown");
+});
 
 // Run the Lambda
 await lambda.RunAsync();

examples/AwsLambda.Host.Example.Testing/Tests/LambdaHostTest.cs

@@ -1,3 +1,4 @@
+using AwesomeAssertions;
 using AwsLambda.Host.Options;
 using AwsLambda.Host.Testing;
 using JetBrains.Annotations;
@@ -14,19 +15,63 @@ public async Task LambdaHost_CanStartWithoutError()
     {
         await using var factory = new LambdaApplicationFactory<Program>();
 
-        var client = factory.CreateClient();
-        // No need to wait for next request - server handles this automatically
-        var response = await client.InvokeAsync<string, string>(
+        var setup = await factory.TestServer.StartAsync(TestContext.Current.CancellationToken);
+
+        setup.InitStatus.Should().Be(InitStatus.InitCompleted);
+
+        var response = await factory.TestServer.InvokeAsync<string, string>(
             "Jonas",
+            "1",
             TestContext.Current.CancellationToken
         );
-        Assert.True(response.WasSuccess);
-        Assert.NotNull(response);
-        Assert.Equal("Hello Jonas!", response.Response);
+
+        response.WasSuccess.Should().BeTrue();
+        response.Should().NotBeNull();
+        response.Response.Should().Be("Hello Jonas!");
     }
 
     [Fact]
-    public async Task LambdaHost_CrashesWithBadConfiguration_ThrowsException()
+    public async Task LambdaHost_HandlerReturnsError()
+    {
+        await using var factory = new LambdaApplicationFactory<Program>();
+
+        var setup = await factory.TestServer.StartAsync(TestContext.Current.CancellationToken);
+
+        setup.InitStatus.Should().Be(InitStatus.InitCompleted);
+
+        var response = await factory.TestServer.InvokeAsync<string, string>(
+            "",
+            TestContext.Current.CancellationToken
+        );
+
+        response.WasSuccess.Should().BeFalse();
+        response.Error.Should().NotBeNull();
+        response.Error?.ErrorMessage.Should().Be("Name is required. (Parameter 'name')");
+    }
+
+    [Fact]
+    public async Task LambdaHost_CanBeShutdown()
+    {
+        await using var factory = new LambdaApplicationFactory<Program>();
+
+        var setup = await factory.TestServer.StartAsync(TestContext.Current.CancellationToken);
+
+        setup.InitStatus.Should().Be(InitStatus.InitCompleted);
+
+        var response = await factory.TestServer.InvokeAsync<string, string>(
+            "Jonas",
+            TestContext.Current.CancellationToken
+        );
+
+        response.WasSuccess.Should().BeTrue();
+        response.Should().NotBeNull();
+        response.Response.Should().Be("Hello Jonas!");
+
+        await factory.TestServer.StopAsync(TestContext.Current.CancellationToken);
+    }
+
+    [Fact]
+    public async Task LambdaHost_ServerInternalExceptions_AreCaughtAndReturnedAsError()
     {
         await using var factory = new LambdaApplicationFactory<Program>().WithHostBuilder(builder =>
         {
@@ -41,28 +86,30 @@ public async Task LambdaHost_CrashesWithBadConfiguration_ThrowsException()
             );
         });
 
-        var client = factory.CreateClient();
-        // No need to wait for next request - server handles this automatically
-        var response = await client.InvokeAsync<string, string>(
-            "Jonas",
-            TestContext.Current.CancellationToken
-        );
-        Assert.True(response.WasSuccess);
-        Assert.NotNull(response);
-        Assert.Equal("Hello Jonas!", response.Response);
+        var act = async () =>
+            await factory.TestServer.StartAsync(TestContext.Current.CancellationToken);
+
+        (await act.Should().ThrowAsync<AggregateException>())
+            .And.InnerExceptions.Should()
+            .ContainSingle(ex =>
+                ex is InvalidOperationException
+                && ex.Message.Contains(
+                    "Unexpected request received from the Lambda HTTP handler: GET http://http//localhost:3002/2018-06-01/runtime/invocation/next"
+                )
+            );
     }
 
     [Fact]
     public async Task LambdaHost_ProcessesConcurrentInvocationsInFifoOrder()
     {
         await using var factory = new LambdaApplicationFactory<Program>();
-        var client = factory.CreateClient();
+        await factory.TestServer.StartAsync(TestContext.Current.CancellationToken);
 
         // Launch 5 concurrent invocations
         var tasks = Enumerable
             .Range(1, 5)
             .Select(i =>
-                client.InvokeAsync<string, string>(
+                factory.TestServer.InvokeAsync<string, string>(
                     $"User{i}",
                     TestContext.Current.CancellationToken
                 )
@@ -84,9 +131,9 @@ public async Task LambdaHost_ProcessesConcurrentInvocationsInFifoOrder()
     public async Task InvokeAsync_WithInvalidPayload_ReturnsError()
     {
         await using var factory = new LambdaApplicationFactory<Program>();
-        var client = factory.CreateClient();
+        await factory.TestServer.StartAsync(TestContext.Current.CancellationToken);
 
-        var response = await client.InvokeAsync<string, int>(
+        var response = await factory.TestServer.InvokeAsync<string, int>(
             123,
             TestContext.Current.CancellationToken
         );
@@ -100,38 +147,46 @@ public async Task InvokeAsync_WithInvalidPayload_ReturnsError()
     public async Task InvokeAsync_WithPreCanceledToken_CancelsInvocation()
     {
         await using var factory = new LambdaApplicationFactory<Program>();
-        var client = factory.CreateClient();
+        await factory.TestServer.StartAsync(TestContext.Current.CancellationToken);
 
         using var cts = new CancellationTokenSource();
         await cts.CancelAsync();
 
         await Assert.ThrowsAsync<TaskCanceledException>(() =>
-            client.InvokeAsync<string, string>("Jonas", cts.Token)
+            factory.TestServer.InvokeAsync<string, string>("Jonas", cts.Token)
         );
     }
 
-    [Fact]
-    public async Task InvokeAsync_WithZeroTimeout_CancelsInvocation() =>
-        await Assert.ThrowsAsync<AggregateException>(async () =>
-        {
-            try
-            {
-                await using var factory = new LambdaApplicationFactory<Program>();
-                var client = factory
-                    .CreateClient()
-                    .ConfigureOptions(options =>
-                        options.InvocationHeaderOptions.ClientWaitTimeout = TimeSpan.Zero
-                    );
-
-                await client.InvokeAsync<string, string>(
-                    "Jonas",
-                    TestContext.Current.CancellationToken
-                );
-            }
-            catch (Exception e)
-            {
-                Console.WriteLine(e.GetType().FullName);
-                throw;
-            }
-        });
+    // [Fact]
+    // public async Task InvokeAsync_WithZeroTimeout_CancelsInvocation() =>
+    //     await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+    //     {
+    //         await using var factory = new LambdaApplicationFactory<Program>();
+    //         await factory.TestServer.StartAsync(TestContext.Current.CancellationToken);
+    //
+    //         var options = new LambdaServerOptions();
+    //         options.InvocationOptions.ClientWaitTimeout = TimeSpan.Zero;
+    //
+    //         await factory.TestServer.InvokeAsync<string, string>(
+    //             "Jonas",
+    //             options,
+    //             TestContext.Current.CancellationToken
+    //         );
+    //     });
+
+    // [Fact]
+    // public async Task StartAsync_WithFailingInit_ReturnsInitError()
+    // {
+    //     // This test verifies that when OnInit returns false (as configured in Program.cs),
+    //     // the runtime posts to /runtime/init/error and StartAsync returns InitResponse with
+    //     //error
+    //     await using var factory = new LambdaApplicationFactory<Program>();
+    //
+    //     using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+    //     var initResponse = await factory.TestServer.StartAsync(cts.Token);
+    //
+    //     Assert.False(initResponse.InitSuccess);
+    //     Assert.NotNull(initResponse.Error);
+    //     Assert.Equal(ServerState.Stopped, factory.TestServer.State);
+    // }
 }

src/AwsLambda.Host.Abstractions/Options/DefaultLambdaJsonSerializerOptions.cs

@@ -0,0 +1,35 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Amazon.Lambda.Serialization.SystemTextJson;
+using Amazon.Lambda.Serialization.SystemTextJson.Converters;
+
+namespace AwsLambda.Host.Options;
+
+/// <summary>Provides the default JSON serializer options used by AWS Lambda.</summary>
+public static class DefaultLambdaJsonSerializerOptions
+{
+    /// <summary>
+    ///     Creates a <see cref="JsonSerializerOptions" /> instance that matches the defaults used by
+    ///     <see cref="DefaultLambdaJsonSerializer" />.
+    /// </summary>
+    /// <remarks>
+    ///     <para>Configures null-value ignoring, case-insensitive property names, and the AWS naming policy.</para>
+    ///     <para>Adds the AWS-provided converters for dates, memory streams, constant classes, and byte arrays.</para>
+    /// </remarks>
+    /// <returns>Configured JSON serializer options suitable for AWS Lambda payloads.</returns>
+    public static JsonSerializerOptions Create()
+    {
+        var options = new JsonSerializerOptions
+        {
+            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+            PropertyNameCaseInsensitive = true,
+            PropertyNamingPolicy = new AwsNamingPolicy(),
+        };
+        options.Converters.Add(new DateTimeConverter());
+        options.Converters.Add(new MemoryStreamConverter());
+        options.Converters.Add(new ConstantClassConverter());
+        options.Converters.Add(new ByteArrayConverter());
+
+        return options;
+    }
+}

src/AwsLambda.Host.Abstractions/Options/EnvelopeOptions.cs

@@ -1,8 +1,6 @@
 using System.Text.Json;
-using System.Text.Json.Serialization;
 using System.Xml;
 using Amazon.Lambda.Serialization.SystemTextJson;
-using Amazon.Lambda.Serialization.SystemTextJson.Converters;
 using AwsLambda.Host.Envelopes;
 
 namespace AwsLambda.Host.Options;
@@ -57,28 +55,8 @@ public class EnvelopeOptions
     ///         not been explicitly configured.
     ///     </para>
     /// </remarks>
-    public JsonSerializerOptions LambdaDefaultJsonOptions
-    {
-        get
-        {
-            if (field is null)
-            {
-                field = new JsonSerializerOptions
-                {
-                    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
-                    PropertyNameCaseInsensitive = true,
-                    PropertyNamingPolicy = new AwsNamingPolicy(),
-                };
-                field.Converters.Add(new DateTimeConverter());
-                field.Converters.Add(new MemoryStreamConverter());
-                field.Converters.Add(new ConstantClassConverter());
-                field.Converters.Add(new ByteArrayConverter());
-            }
-
-            return field;
-        }
-        set;
-    }
+    public JsonSerializerOptions LambdaDefaultJsonOptions { get; set; } =
+        DefaultLambdaJsonSerializerOptions.Create();
 
     /// <summary>Gets or sets the XML reader settings used when deserializing Lambda event payloads.</summary>
     /// <remarks>