Update logic to make DefaultMessageManager fail on InvalidMessageHandlerSignatureException (#169)

Author: GarrettBeatty

.autover/changes/e296733b-6743-445f-a79d-3f2a522f4414.json

@@ -0,0 +1,11 @@
+{
+  "Projects": [
+    {
+      "Name": "AWS.Messaging",
+      "Type": "Patch",
+      "ChangelogMessages": [
+        "Update logic to make DefaultMessageManager fail on InvalidMessageHandlerSignatureException"
+      ]
+    }
+  ]
+}

src/AWS.Messaging/Services/DefaultMessageManager.cs

@@ -175,6 +175,10 @@ private async Task<bool> InvokeHandler(MessageEnvelope messageEnvelope, Subscrib
         {
             await handlerTask;
         }
+        catch (InvalidMessageHandlerSignatureException)
+        {
+            throw;
+        }
         catch (AWSMessagingException)
         {
             // Swallow exceptions thrown by the framework, and rely on the thrower to log

src/AWS.Messaging/Services/HandlerInvoker.cs

@@ -56,13 +56,16 @@ public async Task<MessageProcessStatus> InvokeAsync(MessageEnvelope messageEnvel
 
                 using (var scope = _serviceProvider.CreateScope())
                 {
-                    var handler = scope.ServiceProvider.GetService(subscriberMapping.HandlerType);
-
-                    if (handler == null)
+                    object handler;
+                    try
+                    {
+                        handler = scope.ServiceProvider.GetRequiredService(subscriberMapping.HandlerType);
+                    }
+                    catch (Exception e)
                     {
                         _logger.LogError("Unable to resolve a handler for {HandlerType} while handling message ID {MessageEnvelopeId}.", subscriberMapping.HandlerType, messageEnvelope.Id);
                         throw new InvalidMessageHandlerSignatureException($"Unable to resolve a handler for {subscriberMapping.HandlerType} " +
-                                                                          $"while handling message ID {messageEnvelope.Id}.");
+                                                                          $"while handling message ID {messageEnvelope.Id}.", e);
                     }
 
                     var method = _handlerMethods.GetOrAdd(subscriberMapping.MessageType, x =>

test/AWS.Messaging.UnitTests/DefaultMessageManagerTests.cs

@@ -343,6 +343,40 @@ public async Task DefaultMessageManager_MessageGroupIsSkipped()
             Assert.Equal("2", transactionsInGroupA[1].Id);
         }
 
+        [Fact]
+        public async Task DefaultMessageManager_RethrowsInvalidMessageHandlerSignatureException()
+        {
+            var mockSQSMessageCommunication = CreateMockSQSMessageCommunication();
+            var mockHandlerInvoker = new Mock<IHandlerInvoker>();
+            mockHandlerInvoker
+                .Setup(x => x.InvokeAsync(It.IsAny<MessageEnvelope>(), It.IsAny<SubscriberMapping>(), It.IsAny<CancellationToken>()))
+                .ThrowsAsync(new InvalidMessageHandlerSignatureException("Test exception"));
+
+            var manager = new DefaultMessageManager(
+                mockSQSMessageCommunication.Object,
+                mockHandlerInvoker.Object,
+                new NullLogger<DefaultMessageManager>(),
+                new MessageManagerConfiguration());
+
+            var messageEnvelope = new MessageEnvelope<ChatMessage> { Id = "1" };
+            var subscriberMapping = new SubscriberMapping(typeof(ChatMessageHandler), typeof(ChatMessage));
+
+            await Assert.ThrowsAsync<InvalidMessageHandlerSignatureException>(() =>
+                manager.ProcessMessageAsync(messageEnvelope, subscriberMapping));
+
+            // Verify that the handler was invoked
+            mockHandlerInvoker.Verify(x => x.InvokeAsync(
+                It.Is<MessageEnvelope>(m => m == messageEnvelope),
+                It.Is<SubscriberMapping>(s => s == subscriberMapping),
+                It.IsAny<CancellationToken>()),
+                Times.Once);
+
+            mockSQSMessageCommunication.Verify(x => x.DeleteMessagesAsync(It.IsAny<IEnumerable<MessageEnvelope>>(), It.IsAny<CancellationToken>()), Times.Never);
+            mockSQSMessageCommunication.Verify(x => x.ReportMessageFailureAsync(It.IsAny<MessageEnvelope>(), It.IsAny<CancellationToken>()), Times.Never);
+
+            Assert.Equal(0, manager.ActiveMessageCount);
+        }
+
         private MessageEnvelope<TransactionInfo> CreateTransactionEnvelope(string id, string userId, bool shouldFail)
         {
             return new MessageEnvelope<TransactionInfo>

test/AWS.Messaging.UnitTests/HandlerInvokerTests.cs

@@ -1,6 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using AWS.Messaging.Configuration;
@@ -154,4 +155,32 @@ public async Task HandlerInvoker_VerifyHandlersAreRetrievedAsScopedDependencies(
         }
         Assert.Equal(3, messageStorage2.Count);
     }
+
+    [Fact]
+    public async Task HandlerInvoker_VerifyHandlersFatalErrorWhenDIFails()
+    {
+        var serviceCollection = new ServiceCollection()
+           .AddAWSMessageBus(builder =>
+           {
+               builder.AddMessageHandler<ChatMessageHandlerWithDependencies, ChatMessage>();
+           }).AddSingleton<IDependentThing>(x =>
+           {
+               var thingDoer = x.GetRequiredService<IThingDoer>();
+               throw new InvalidOperationException("Blah blah"); // intentionally make the DI fail.
+           });
+
+        var serviceProvider = serviceCollection.BuildServiceProvider();
+
+        var handlerInvoker = new HandlerInvoker(
+            serviceProvider,
+            new NullLogger<HandlerInvoker>(),
+            new DefaultTelemetryFactory(serviceProvider));
+
+        var envelope = new MessageEnvelope<ChatMessage>();
+        var subscriberMapping = new SubscriberMapping(typeof(ChatMessageHandlerWithDependencies), typeof(ChatMessage));
+        await Assert.ThrowsAsync<InvalidMessageHandlerSignatureException>(async () =>
+        {
+            await handlerInvoker.InvokeAsync(envelope, subscriberMapping);
+        });
+    }
 }

test/AWS.Messaging.UnitTests/MessageHandlers/DependentThing.cs

@@ -0,0 +1,20 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+namespace AWS.Messaging.UnitTests.MessageHandlers;
+
+public class DependentThing : IDependentThing
+{
+    private readonly IThingDoer _ThingDoer;
+
+    public DependentThing(IThingDoer thingDoer)
+    {
+        _ThingDoer = thingDoer;
+    }
+
+
+    public void DoThingWithThing()
+    {
+        _ThingDoer.DoThing();
+    }
+}

test/AWS.Messaging.UnitTests/MessageHandlers/Handlers.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using Amazon.Lambda.Core;
 using AWS.Messaging.UnitTests.Models;
 using Microsoft.Extensions.DependencyInjection;
 using Xunit;
@@ -27,6 +28,22 @@ public Task<MessageProcessStatus> HandleAsync(MessageEnvelope<AddressInfo> messa
     }
 }
 
+public class ChatMessageHandlerWithDependencies : IMessageHandler<ChatMessage>
+{
+    private readonly IDependentThing _thingDoer;
+
+    public ChatMessageHandlerWithDependencies(IDependentThing thingDoer)
+    {
+        _thingDoer = thingDoer;
+    }
+
+    public Task<MessageProcessStatus> HandleAsync(MessageEnvelope<ChatMessage> messageEnvelope, CancellationToken token = default)
+    {
+        _thingDoer.DoThingWithThing();
+        return Task.FromResult(MessageProcessStatus.Success());
+    }
+}
+
 /// <summary>
 /// Implements handling for mutiple message types
 /// </summary>

test/AWS.Messaging.UnitTests/MessageHandlers/IDependentThing.cs

@@ -0,0 +1,9 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+namespace AWS.Messaging.UnitTests.MessageHandlers;
+
+public interface IDependentThing
+{
+    void DoThingWithThing();
+}

test/AWS.Messaging.UnitTests/MessageHandlers/IThingDoer.cs

@@ -0,0 +1,9 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+namespace AWS.Messaging.UnitTests.MessageHandlers;
+
+public interface IThingDoer
+{
+    string DoThing();
+}

test/AWS.Messaging.UnitTests/MessageHandlers/ThingDoer.cs

@@ -0,0 +1,12 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+namespace AWS.Messaging.UnitTests.MessageHandlers;
+
+public class ThingDoer : IThingDoer
+{
+    public string DoThing()
+    {
+        return "I did a thing!";
+    }
+}