Extend tests

- Extend the integration tests to include publishing to multiple topics in a single batch.
- Fix broken test assertion after previous refactor.
- Disable IDE0130.

.editorconfig

@@ -43,6 +43,7 @@ dotnet_naming_style.attribute_upper_camel_case_style.required_prefix=Attribute
 dotnet_naming_symbols.private_constants_symbols.applicable_accessibilities=private
 dotnet_naming_symbols.private_constants_symbols.applicable_kinds=field
 dotnet_naming_symbols.private_constants_symbols.required_modifiers=const
+dotnet_style_namespace_match_folder=false
 dotnet_style_parentheses_in_arithmetic_binary_operators=never_if_unnecessary:none
 dotnet_style_parentheses_in_other_binary_operators=never_if_unnecessary:none
 dotnet_style_parentheses_in_relational_binary_operators=never_if_unnecessary:none

tests/JustSaying.IntegrationTests/Fluent/Publishing/WhenAMessageIsPublishedToAQueue.cs

@@ -85,4 +85,65 @@ await WhenBatchAsync(
                 await handler.Received(batchSize).Handle(Arg.Is<SimpleMessage>((m) => messages.Any(y => y.Id == m.Id)));
             });
     }
+
+    [AwsTheory]
+    [InlineData(10, 10)]
+    [InlineData(10, 100)]
+    [InlineData(5, 100)]
+    public async Task Then_Multiple_Message_Types_Are_Handled(int maxBatchSize, int batchSize)
+    {
+        // Arrange
+        var completionSource1 = new TaskCompletionSource<object>();
+        var handler1 = CreateHandler<SimpleMessage>(completionSource1, batchSize);
+
+        var completionSource2 = new TaskCompletionSource<object>();
+        var handler2 = CreateHandler<AnotherSimpleMessage>(completionSource2, batchSize);
+
+        var services = GivenJustSaying()
+            .ConfigureJustSaying((builder) =>
+            {
+                builder.WithLoopbackQueue<SimpleMessage>(UniqueName);
+                builder.WithLoopbackQueue<AnotherSimpleMessage>(UniqueName + "ish");
+            })
+            .AddSingleton(handler1)
+            .AddSingleton(handler2);
+
+        var messages = new List<Message>();
+        for (int i = 0; i < batchSize; i++)
+        {
+            messages.Add(new SimpleMessage
+            {
+                Content = $"Message {i} of {batchSize} with max batch size {maxBatchSize}"
+            });
+        }
+
+        for (int i = 0; i < batchSize; i++)
+        {
+            messages.Add(new AnotherSimpleMessage
+            {
+                Content = $"Message {i} of {batchSize} with max batch size {maxBatchSize}"
+            });
+        }
+
+        await WhenBatchAsync(
+            services,
+            async (publisher, listener, cancellationToken) =>
+            {
+                await listener.StartAsync(cancellationToken);
+                await publisher.StartAsync(cancellationToken);
+
+                // Act
+                await publisher.PublishAsync(messages, new PublishBatchMetadata
+                {
+                    BatchSize = maxBatchSize
+                }, cancellationToken);
+
+                // Assert
+                completionSource1.Task.Wait(cancellationToken);
+                await handler1.Received(batchSize).Handle(Arg.Is<SimpleMessage>((m) => messages.Any(y => y.Id == m.Id)));
+
+                completionSource2.Task.Wait(cancellationToken);
+                await handler2.Received(batchSize).Handle(Arg.Is<AnotherSimpleMessage>((m) => messages.Any(y => y.Id == m.Id)));
+            });
+    }
 }

tests/JustSaying.IntegrationTests/Fluent/Publishing/WhenAMessageIsPublishedToATopic.cs

@@ -85,4 +85,65 @@ await WhenBatchAsync(
                 await handler.Received(batchSize).Handle(Arg.Is<SimpleMessage>((m) => messages.Any(x => x.Id == m.Id)));
             });
     }
+
+    [AwsTheory]
+    [InlineData(10, 10)]
+    [InlineData(10, 20)]
+    [InlineData(5, 10)]
+    public async Task Then_Multiple_Message_Types_Are_Handled(int maxBatchSize, int batchSize)
+    {
+        // Arrange
+        var completionSource1 = new TaskCompletionSource<object>();
+        var handler1 = CreateHandler<SimpleMessage>(completionSource1, batchSize);
+
+        var completionSource2 = new TaskCompletionSource<object>();
+        var handler2 = CreateHandler<AnotherSimpleMessage>(completionSource2, batchSize);
+
+        var services = GivenJustSaying()
+            .ConfigureJustSaying((builder) =>
+            {
+                builder.WithLoopbackTopic<SimpleMessage>(UniqueName);
+                builder.WithLoopbackTopic<AnotherSimpleMessage>(UniqueName + "ish");
+            })
+            .AddSingleton(handler1)
+            .AddSingleton(handler2);
+
+        var messages = new List<Message>();
+        for (int i = 0; i < batchSize; i++)
+        {
+            messages.Add(new SimpleMessage
+            {
+                Content = $"Message {i} of {batchSize} with max batch size {maxBatchSize}"
+            });
+        }
+
+        for (int i = 0; i < batchSize; i++)
+        {
+            messages.Add(new AnotherSimpleMessage
+            {
+                Content = $"Message {i} of {batchSize} with max batch size {maxBatchSize}"
+            });
+        }
+
+        await WhenBatchAsync(
+            services,
+            async (publisher, listener, cancellationToken) =>
+            {
+                await listener.StartAsync(cancellationToken);
+                await publisher.StartAsync(cancellationToken);
+
+                // Act
+                await publisher.PublishAsync(messages, new PublishBatchMetadata
+                {
+                    BatchSize = batchSize
+                }, cancellationToken);
+
+                // Assert
+                completionSource1.Task.Wait(cancellationToken);
+                await handler1.Received(batchSize).Handle(Arg.Is<SimpleMessage>((m) => messages.Any(x => x.Id == m.Id)));
+
+                completionSource2.Task.Wait(cancellationToken);
+                await handler2.Received(batchSize).Handle(Arg.Is<AnotherSimpleMessage>((m) => messages.Any(x => x.Id == m.Id)));
+            });
+    }
 }

tests/JustSaying.IntegrationTests/Fluent/Publishing/WhenPublishingWithNoRegisteredMessages.cs

@@ -1,5 +1,4 @@
 using JustSaying.Messaging;
-using JustSaying.Models;
 using JustSaying.TestingFramework;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -26,7 +25,7 @@ public async Task Then_An_Exception_Is_Thrown()
         await batchPublisher.StartAsync(CancellationToken.None);
 
         // Act and Assert
-        exception = await Assert.ThrowsAsync<InvalidOperationException>(() => batchPublisher.PublishAsync(new List<Message> {new SimpleMessage() }, CancellationToken.None));
-        exception.Message.ShouldBe("Error publishing message, no publishers registered. Has the bus been started?");
+        exception = await Assert.ThrowsAsync<InvalidOperationException>(() => batchPublisher.PublishAsync([new SimpleMessage()], CancellationToken.None));
+        exception.Message.ShouldBe("Error publishing message batch, no publishers registered. Has the bus been started?");
     }
 }

tests/JustSaying.TestingFramework/TestEnvironment.cs

@@ -36,7 +36,7 @@ public static RegionEndpoint Region
     /// <summary>
     /// Gets a value indicating whether an AWS simulator is configured for use.
     /// </summary>
-    public static bool IsSimulatorConfigured => (SimulatorUrl != null);
+    public static bool IsSimulatorConfigured => SimulatorUrl != null;
 
     /// <summary>
     /// Gets the URL for the configured AWS simulator, if any.
@@ -111,4 +111,4 @@ public static RegionEndpoint SecondaryRegion
     private static string RegionName => Environment.GetEnvironmentVariable("AWS_REGION");
 
     private static string SecondaryRegionName => Environment.GetEnvironmentVariable("AWS_REGION_SECONDARY");
-}
+}