Fix StructureMap Transient Middleware Resolution

src/JustSaying.Extensions.DependencyInjection.StructureMap/JustSayingRegistry.cs

@@ -41,8 +41,8 @@ public JustSayingRegistry()
         For<IMessageContextAccessor>().Use(context => context.GetInstance<MessageContextAccessor>());
         For<IMessageContextReader>().Use(context => context.GetInstance<MessageContextAccessor>());
 
-        For<LoggingMiddleware>().Transient();
-        For<SqsPostProcessorMiddleware>().Transient();
+        For<LoggingMiddleware>().AlwaysUnique();
+        For<SqsPostProcessorMiddleware>().AlwaysUnique();
 
         For<IMessageSerializationRegister>()
             .Use(

src/JustSaying/Messaging/Middleware/Handle/HandlerMiddlewareBuilder.cs

@@ -38,7 +38,7 @@
         {
             throw new InvalidOperationException(
                 @"Middlewares must be registered into your DI container such that each resolution creates a new instance.
-For StructureMap use Transient(), and for Microsoft.Extensions.DependencyInjection, use AddTransient().
+For StructureMap use AlwaysUnique(), and for Microsoft.Extensions.DependencyInjection, use AddTransient().
 Please check the documentation for your container for more details.");
         }
 

tests/JustSaying.Extensions.DependencyInjection.StructureMap.Tests/StructureMapTests.cs

@@ -1,5 +1,9 @@
+using JustSaying.Fluent;
 using JustSaying.Messaging;
 using JustSaying.Messaging.MessageHandling;
+using JustSaying.Messaging.Middleware;
+using JustSaying.Messaging.Middleware.Logging;
+using JustSaying.Messaging.Middleware.PostProcessing;
 using JustSaying.TestingFramework;
 using Microsoft.Extensions.Logging;
 using Shouldly;
@@ -64,4 +68,41 @@ public async Task Can_Create_Messaging_Bus_Fluently_For_A_Queue()
         // Assert
         handler.ReceivedMessages.ShouldContain(x => x.GetType() == typeof(SimpleMessage));
     }
+
+    [AwsFact]
+    public void Registers_Middleware_With_The_Correct_Lifetime()
+    {
+        // Arrange
+        using var container = new Container(
+            (registry) =>
+            {
+                registry.For<ILoggerFactory>()
+                    .Use(() => OutputHelper.ToLoggerFactory())
+                    .Singleton();
+
+                registry.AddJustSaying(
+                    (builder) =>
+                    {
+                        builder.Client((options) =>
+                                options.WithBasicCredentials("accessKey", "secretKey")
+                                    .WithServiceUri(TestEnvironment.SimulatorUrl))
+                            .Messaging((options) => options.WithRegion("eu-west-1"));
+                    });
+            });
+
+        var handlerMiddlewareBuilder = new HandlerMiddlewareBuilder(container.GetInstance<IHandlerResolver>(), container.GetInstance<IServiceResolver>());
+        var useLoggingMiddlewareTwice = () => UseMiddlewareTwice<LoggingMiddleware>();
+        var useSqsPostProcessorMiddlewareTwice = () => UseMiddlewareTwice<SqsPostProcessorMiddleware>();
+
+        void UseMiddlewareTwice<T>()
+            where T : MiddlewareBase<HandleMessageContext, bool>
+        {
+            handlerMiddlewareBuilder.Use<LoggingMiddleware>();
+            handlerMiddlewareBuilder.Use<LoggingMiddleware>();
+        }
+
+        // Act + Assert
+        useLoggingMiddlewareTwice.ShouldNotThrow();
+        useSqsPostProcessorMiddlewareTwice.ShouldNotThrow();
+    }
 }

tests/JustSaying.TestingFramework/Patiently.cs

@@ -31,16 +31,20 @@ public static async Task AssertThatAsync(
         ITestOutputHelper output,
         Func<bool> func,
         [System.Runtime.CompilerServices.CallerMemberName]
-        string memberName = "")
-        => await AssertThatAsyncInner(output, func, 5.Seconds(), memberName).ConfigureAwait(false);
+        string memberName = "",
+        [System.Runtime.CompilerServices.CallerArgumentExpression("func")]
+        string assertionExpression = "")
+        => await AssertThatAsyncInner(output, func, 5.Seconds(), memberName, assertionExpression).ConfigureAwait(false);
 
     public static async Task AssertThatAsync(
         ITestOutputHelper output,
         Func<bool> func,
         TimeSpan timeout,
         [System.Runtime.CompilerServices.CallerMemberName]
-        string memberName = "")
-        => await AssertThatAsyncInner(output, func, timeout, memberName).ConfigureAwait(false);
+        string memberName = "",
+        [System.Runtime.CompilerServices.CallerArgumentExpression("func")]
+        string assertionExpression = "")
+        => await AssertThatAsyncInner(output, func, timeout, memberName, assertionExpression).ConfigureAwait(false);
 
     public static async Task AssertThatAsync(ITestOutputHelper output, Func<Task<bool>> func) =>
         await AssertThatAsync(output, func, 5.Seconds()).ConfigureAwait(false);
@@ -80,7 +84,8 @@ private static async Task AssertThatAsyncInner(
         ITestOutputHelper output,
         Func<bool> func,
         TimeSpan timeout,
-        string description)
+        string description,
+        string assertionExpression)
     {
         var watch = new Stopwatch();
         watch.Start();
@@ -106,7 +111,7 @@ private static async Task AssertThatAsyncInner(
                 $"Waiting for {watch.Elapsed.TotalMilliseconds} ms - Still waiting for {description}.");
         } while (watch.Elapsed < timeout);
 
-        func.Invoke().ShouldBeTrue();
+        func.Invoke().ShouldBeTrue($"Failed to assert that {assertionExpression} within {timeout}");
     }
 }