From 9d430d861d18b56fbdd06c7a8df8bc6f51ae5199 Mon Sep 17 00:00:00 2001 From: "Dabadie, Romain" Date: Mon, 27 Jul 2026 13:20:12 -0400 Subject: [PATCH 1/2] test: add Testcontainers integration suite Add sequential broker round-trip tests for RabbitMQ, Kafka, MQTT, NATS, Azure Service Bus, and Azure Event Hubs, with dedicated CI execution and documentation. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .github/workflows/build.yml | 8 +- .../AssemblyInfo.cs | 3 + .../AzureEventHubsIntegrationTests.cs | 109 ++++++++++++++++++ .../AzureServiceBusIntegrationTests.cs | 106 +++++++++++++++++ .../Infrastructure/EventHubs/Config.json | 24 ++++ .../Infrastructure/ServiceBus/Config.json | 18 +++ .../KafkaIntegrationTests.cs | 58 ++++++++++ .../MessageValidation.IntegrationTests.csproj | 45 ++++++++ .../MqttIntegrationTests.cs | 51 ++++++++ .../NatsIntegrationTests.cs | 55 +++++++++ .../RabbitMqIntegrationTests.cs | 45 ++++++++ .../RecordingPipeline.cs | 16 +++ MessageValidation.slnx | 1 + README.md | 20 ++++ 14 files changed, 556 insertions(+), 3 deletions(-) create mode 100644 MessageValidation.IntegrationTests/AssemblyInfo.cs create mode 100644 MessageValidation.IntegrationTests/AzureEventHubsIntegrationTests.cs create mode 100644 MessageValidation.IntegrationTests/AzureServiceBusIntegrationTests.cs create mode 100644 MessageValidation.IntegrationTests/Infrastructure/EventHubs/Config.json create mode 100644 MessageValidation.IntegrationTests/Infrastructure/ServiceBus/Config.json create mode 100644 MessageValidation.IntegrationTests/KafkaIntegrationTests.cs create mode 100644 MessageValidation.IntegrationTests/MessageValidation.IntegrationTests.csproj create mode 100644 MessageValidation.IntegrationTests/MqttIntegrationTests.cs create mode 100644 MessageValidation.IntegrationTests/NatsIntegrationTests.cs create mode 100644 MessageValidation.IntegrationTests/RabbitMqIntegrationTests.cs create mode 100644 MessageValidation.IntegrationTests/RecordingPipeline.cs diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 4487401..287dcec 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -24,8 +24,11 @@ jobs: - name: Build run: dotnet build MessageValidation.slnx --configuration Release --no-restore - - name: Test - run: dotnet test MessageValidation.slnx --configuration Release --no-build --verbosity normal + - name: Unit tests + run: dotnet test MessageValidation.slnx --configuration Release --no-build --filter "Category!=Integration" --verbosity normal + + - name: Integration tests + run: dotnet test MessageValidation.IntegrationTests/MessageValidation.IntegrationTests.csproj --configuration Release --no-build --filter "Category=Integration" --verbosity normal - name: Pack (validate packages) run: | @@ -38,4 +41,3 @@ jobs: dotnet pack MessageValidation.Kafka/MessageValidation.Kafka.csproj --configuration Release --no-build --output ./nupkgs dotnet pack MessageValidation.AzureServiceBus/MessageValidation.AzureServiceBus.csproj --configuration Release --no-build --output ./nupkgs dotnet pack MessageValidation.AzureEventHubs/MessageValidation.AzureEventHubs.csproj --configuration Release --no-build --output ./nupkgs - diff --git a/MessageValidation.IntegrationTests/AssemblyInfo.cs b/MessageValidation.IntegrationTests/AssemblyInfo.cs new file mode 100644 index 0000000..2171200 --- /dev/null +++ b/MessageValidation.IntegrationTests/AssemblyInfo.cs @@ -0,0 +1,3 @@ +using Xunit; + +[assembly: CollectionBehavior(DisableTestParallelization = true)] diff --git a/MessageValidation.IntegrationTests/AzureEventHubsIntegrationTests.cs b/MessageValidation.IntegrationTests/AzureEventHubsIntegrationTests.cs new file mode 100644 index 0000000..db8a50d --- /dev/null +++ b/MessageValidation.IntegrationTests/AzureEventHubsIntegrationTests.cs @@ -0,0 +1,109 @@ +using System.Net; +using Azure.Messaging.EventHubs; +using Azure.Messaging.EventHubs.Consumer; +using Azure.Messaging.EventHubs.Producer; +using DotNet.Testcontainers.Builders; +using DotNet.Testcontainers.Configurations; +using MessageValidation.AzureEventHubs; +using Testcontainers.Azurite; + +namespace MessageValidation.IntegrationTests; + +public class AzureEventHubsIntegrationTests +{ + private const string ConsumerGroup = "integration-group"; + private const string EventHubName = "integration-hub"; + + [Fact] + [Trait("Category", "Integration")] + public async Task Consumer_ReceivesEventThroughValidationPipeline() + { + using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(5)); + var ct = timeout.Token; + var configPath = Path.Combine( + AppContext.BaseDirectory, + "Infrastructure", + "EventHubs", + "Config.json"); + + await using var network = new NetworkBuilder().Build(); + await using var azurite = new AzuriteBuilder( + "mcr.microsoft.com/azure-storage/azurite:3.36.0") + .WithNetwork(network) + .WithNetworkAliases("azurite") + .Build(); + await using var emulator = new ContainerBuilder( + "mcr.microsoft.com/azure-messaging/eventhubs-emulator:2.2.1") + .WithBindMount( + configPath, + "/Eventhubs_Emulator/ConfigFiles/Config.json", + AccessMode.ReadOnly) + .WithEnvironment("ACCEPT_EULA", "Y") + .WithEnvironment("BLOB_SERVER", "azurite") + .WithEnvironment("METADATA_SERVER", "azurite") + .WithNetwork(network) + .WithNetworkAliases("eventhubs-emulator") + .WithPortBinding(5672, true) + .WithPortBinding(9092, true) + .WithPortBinding(5300, true) + .WithWaitStrategy(Wait.ForUnixContainer() + .UntilHttpRequestIsSucceeded(request => request + .ForPort(5300) + .ForPath("/health") + .ForStatusCode(HttpStatusCode.OK))) + .Build(); + + await network.CreateAsync(ct); + await azurite.StartAsync(ct); + await emulator.StartAsync(ct); + + var connectionString = + $"Endpoint=sb://{emulator.Hostname}:{emulator.GetMappedPublicPort(5672)};" + + "SharedAccessKeyName=RootManageSharedAccessKey;" + + "SharedAccessKey=SAS_KEY_VALUE;UseDevelopmentEmulator=true;"; + + await using var producer = new EventHubProducerClient(connectionString, EventHubName); + await using var consumer = new EventHubConsumerClient( + ConsumerGroup, + connectionString, + EventHubName); + var pipeline = new RecordingPipeline(); + using var consumingCts = CancellationTokenSource.CreateLinkedTokenSource(ct); + var consumingTask = consumer.StartConsuming( + pipeline, + startReadingAtEarliestEvent: true, + ct: consumingCts.Token); + + var payload = """{"temperature":21.5}"""u8.ToArray(); + MessageContext context; + + try + { + var eventData = new EventData(new BinaryData(payload)) + { + MessageId = "eventhubs-integration-1", + CorrelationId = "correlation-1", + ContentType = "application/json" + }; + eventData.Properties["test"] = "integration"; + + await producer.SendAsync([eventData], ct); + context = await pipeline.WaitAsync(ct); + } + finally + { + await consumingCts.CancelAsync(); + await consumingTask.WaitAsync(TimeSpan.FromSeconds(30)); + } + + Assert.Equal(payload, context.RawPayload); + Assert.Equal(EventHubName, context.Source); + Assert.Equal(EventHubName, context.Metadata["eventhubs.eventHubName"]); + Assert.Equal("eventhubs-integration-1", context.Metadata["eventhubs.messageId"]); + Assert.Equal("application/json", context.Metadata["eventhubs.contentType"]); + Assert.NotEmpty(Assert.IsType(context.Metadata["eventhubs.partitionId"])); + var properties = Assert.IsAssignableFrom>( + context.Metadata["eventhubs.properties"]); + Assert.Equal("integration", properties["test"]); + } +} diff --git a/MessageValidation.IntegrationTests/AzureServiceBusIntegrationTests.cs b/MessageValidation.IntegrationTests/AzureServiceBusIntegrationTests.cs new file mode 100644 index 0000000..63c5bf4 --- /dev/null +++ b/MessageValidation.IntegrationTests/AzureServiceBusIntegrationTests.cs @@ -0,0 +1,106 @@ +using System.Net; +using Azure.Messaging.ServiceBus; +using DotNet.Testcontainers.Builders; +using DotNet.Testcontainers.Configurations; +using MessageValidation.AzureServiceBus; +using Testcontainers.MsSql; + +namespace MessageValidation.IntegrationTests; + +public class AzureServiceBusIntegrationTests +{ + private const string QueueName = "integration-queue"; + private const string SqlPassword = "MessageValidation1!"; + + [Fact] + [Trait("Category", "Integration")] + public async Task Processor_ReceivesMessageThroughValidationPipeline() + { + using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(5)); + var ct = timeout.Token; + var configPath = Path.Combine( + AppContext.BaseDirectory, + "Infrastructure", + "ServiceBus", + "Config.json"); + + await using var network = new NetworkBuilder().Build(); + await using var sql = new MsSqlBuilder( + "mcr.microsoft.com/mssql/server:2022-CU26-ubuntu-22.04") + .WithPassword(SqlPassword) + .WithEnvironment("ACCEPT_EULA", "Y") + .WithNetwork(network) + .WithNetworkAliases("mssql") + .Build(); + await using var emulator = new ContainerBuilder( + "mcr.microsoft.com/azure-messaging/servicebus-emulator:2.0.1") + .WithBindMount( + configPath, + "/ServiceBus_Emulator/ConfigFiles/Config.json", + AccessMode.ReadOnly) + .WithEnvironment("ACCEPT_EULA", "Y") + .WithEnvironment("SQL_SERVER", "mssql") + .WithEnvironment("MSSQL_SA_PASSWORD", SqlPassword) + .WithEnvironment("EMULATOR_HTTP_PORT", "5300") + .WithNetwork(network) + .WithNetworkAliases("servicebus-emulator") + .WithPortBinding(5672, true) + .WithPortBinding(5300, true) + .WithWaitStrategy(Wait.ForUnixContainer() + .UntilHttpRequestIsSucceeded(request => request + .ForPort(5300) + .ForPath("/health") + .ForStatusCode(HttpStatusCode.OK))) + .Build(); + + await network.CreateAsync(ct); + await sql.StartAsync(ct); + await emulator.StartAsync(ct); + + var connectionString = + $"Endpoint=sb://{emulator.Hostname}:{emulator.GetMappedPublicPort(5672)};" + + "SharedAccessKeyName=RootManageSharedAccessKey;" + + "SharedAccessKey=SAS_KEY_VALUE;UseDevelopmentEmulator=true;"; + + await using var client = new ServiceBusClient(connectionString); + await using var sender = client.CreateSender(QueueName); + await using var processor = client.CreateProcessor( + QueueName, + new ServiceBusProcessorOptions { MaxConcurrentCalls = 1 }); + var pipeline = new RecordingPipeline(); + processor.UseMessageValidation(pipeline); + + var payload = """{"orderId":42}"""u8.ToArray(); + MessageContext context; + + await processor.StartProcessingAsync(ct); + try + { + var message = new ServiceBusMessage(new BinaryData(payload)) + { + MessageId = "servicebus-integration-1", + Subject = "order.created", + CorrelationId = "correlation-1", + ContentType = "application/json" + }; + message.ApplicationProperties["test"] = "integration"; + + await sender.SendMessageAsync(message, ct); + context = await pipeline.WaitAsync(ct); + } + finally + { + using var stopTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(30)); + await processor.StopProcessingAsync(stopTimeout.Token); + } + + Assert.Equal(payload, context.RawPayload); + Assert.Equal("order.created", context.Source); + Assert.Equal(QueueName, context.Metadata["servicebus.entityPath"]); + Assert.Equal("servicebus-integration-1", context.Metadata["servicebus.messageId"]); + Assert.Equal("application/json", context.Metadata["servicebus.contentType"]); + var properties = Assert.IsAssignableFrom>( + context.Metadata["servicebus.applicationProperties"]); + Assert.Equal("integration", properties["test"]); + } +} diff --git a/MessageValidation.IntegrationTests/Infrastructure/EventHubs/Config.json b/MessageValidation.IntegrationTests/Infrastructure/EventHubs/Config.json new file mode 100644 index 0000000..33913fc --- /dev/null +++ b/MessageValidation.IntegrationTests/Infrastructure/EventHubs/Config.json @@ -0,0 +1,24 @@ +{ + "UserConfig": { + "NamespaceConfig": [ + { + "Type": "EventHub", + "Name": "emulatorNs1", + "Entities": [ + { + "Name": "integration-hub", + "PartitionCount": 1, + "ConsumerGroups": [ + { + "Name": "integration-group" + } + ] + } + ] + } + ], + "LoggingConfig": { + "Type": "Console" + } + } +} diff --git a/MessageValidation.IntegrationTests/Infrastructure/ServiceBus/Config.json b/MessageValidation.IntegrationTests/Infrastructure/ServiceBus/Config.json new file mode 100644 index 0000000..7bb5aa0 --- /dev/null +++ b/MessageValidation.IntegrationTests/Infrastructure/ServiceBus/Config.json @@ -0,0 +1,18 @@ +{ + "UserConfig": { + "Namespaces": [ + { + "Name": "sbemulatorns", + "Queues": [ + { + "Name": "integration-queue" + } + ], + "Topics": [] + } + ], + "Logging": { + "Type": "Console" + } + } +} diff --git a/MessageValidation.IntegrationTests/KafkaIntegrationTests.cs b/MessageValidation.IntegrationTests/KafkaIntegrationTests.cs new file mode 100644 index 0000000..26f838d --- /dev/null +++ b/MessageValidation.IntegrationTests/KafkaIntegrationTests.cs @@ -0,0 +1,58 @@ +using Confluent.Kafka; +using MessageValidation.Kafka; +using Testcontainers.Kafka; + +namespace MessageValidation.IntegrationTests; + +public sealed class KafkaIntegrationTests +{ + [Fact] + [Trait("Category", "Integration")] + public async Task ProducedMessage_ReachesValidationPipeline() + { + using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(5)); + await using var container = new KafkaBuilder("confluentinc/cp-kafka:7.5.12").Build(); + await container.StartAsync(timeout.Token); + + var topic = $"message-validation-{Guid.NewGuid():N}"; + var payload = """{"transport":"kafka"}"""u8.ToArray(); + + using (var producer = new ProducerBuilder(new ProducerConfig + { + BootstrapServers = container.GetBootstrapAddress() + }).Build()) + { + await producer.ProduceAsync( + topic, + new Message { Key = "integration", Value = payload }, + timeout.Token); + } + + using var consumer = new ConsumerBuilder(new ConsumerConfig + { + BootstrapServers = container.GetBootstrapAddress(), + GroupId = $"message-validation-{Guid.NewGuid():N}", + AutoOffsetReset = AutoOffsetReset.Earliest + }).Build(); + + using var consumeCancellation = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token); + var pipeline = new RecordingPipeline(); + var consumeTask = consumer.StartConsuming(pipeline, [topic], consumeCancellation.Token); + + MessageContext context; + try + { + context = await pipeline.WaitAsync(timeout.Token); + } + finally + { + await consumeCancellation.CancelAsync(); + await consumeTask; + consumer.Close(); + } + + Assert.Equal(topic, context.Source); + Assert.Equal(payload, context.RawPayload); + Assert.Equal(topic, context.Metadata["kafka.topic"]); + } +} diff --git a/MessageValidation.IntegrationTests/MessageValidation.IntegrationTests.csproj b/MessageValidation.IntegrationTests/MessageValidation.IntegrationTests.csproj new file mode 100644 index 0000000..f3d2923 --- /dev/null +++ b/MessageValidation.IntegrationTests/MessageValidation.IntegrationTests.csproj @@ -0,0 +1,45 @@ + + + + net10.0 + enable + enable + 14.0 + false + + + + + + + + + + + + + + + + + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + + \ No newline at end of file diff --git a/MessageValidation.IntegrationTests/MqttIntegrationTests.cs b/MessageValidation.IntegrationTests/MqttIntegrationTests.cs new file mode 100644 index 0000000..bc72699 --- /dev/null +++ b/MessageValidation.IntegrationTests/MqttIntegrationTests.cs @@ -0,0 +1,51 @@ +using MessageValidation.MqttNet; +using MQTTnet; +using Testcontainers.Mosquitto; + +namespace MessageValidation.IntegrationTests; + +public sealed class MqttIntegrationTests +{ + [Fact] + [Trait("Category", "Integration")] + public async Task PublishedMessage_ReachesValidationPipeline() + { + using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(5)); + await using var container = new MosquittoBuilder("eclipse-mosquitto:2.0.22").Build(); + await container.StartAsync(timeout.Token); + + var subscriberOptions = new MqttClientOptionsBuilder() + .WithTcpServer(container.Hostname, container.MqttPort) + .Build(); + var publisherOptions = new MqttClientOptionsBuilder() + .WithTcpServer(container.Hostname, container.MqttPort) + .Build(); + + var clientFactory = new MqttClientFactory(); + using var subscriber = clientFactory.CreateMqttClient(); + using var publisher = clientFactory.CreateMqttClient(); + + var pipeline = new RecordingPipeline(); + subscriber.UseMessageValidation(pipeline); + + await subscriber.ConnectAsync(subscriberOptions, timeout.Token); + await publisher.ConnectAsync(publisherOptions, timeout.Token); + + var topic = $"message-validation/{Guid.NewGuid():N}"; + await subscriber.SubscribeAsync(topic, cancellationToken: timeout.Token); + + var payload = """{"transport":"mqtt"}"""u8.ToArray(); + var message = new MqttApplicationMessageBuilder() + .WithTopic(topic) + .WithPayload(payload) + .Build(); + + await publisher.PublishAsync(message, timeout.Token); + + var context = await pipeline.WaitAsync(timeout.Token); + + Assert.Equal(topic, context.Source); + Assert.Equal(payload, context.RawPayload); + Assert.Equal(message.QualityOfServiceLevel, context.Metadata["mqtt.qos"]); + } +} diff --git a/MessageValidation.IntegrationTests/NatsIntegrationTests.cs b/MessageValidation.IntegrationTests/NatsIntegrationTests.cs new file mode 100644 index 0000000..8b234d7 --- /dev/null +++ b/MessageValidation.IntegrationTests/NatsIntegrationTests.cs @@ -0,0 +1,55 @@ +using MessageValidation.NatsNet; +using NATS.Client.Core; +using Testcontainers.Nats; + +namespace MessageValidation.IntegrationTests; + +public sealed class NatsIntegrationTests +{ + [Fact] + [Trait("Category", "Integration")] + public async Task PublishedMessage_ReachesValidationPipeline() + { + using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(5)); + await using var container = new NatsBuilder("nats:2.12.11").Build(); + await container.StartAsync(timeout.Token); + + await using var connection = new NatsConnection( + NatsOpts.Default with { Url = container.GetConnectionString() }); + await connection.ConnectAsync(); + + var subject = $"message-validation.{Guid.NewGuid():N}"; + var payload = """{"transport":"nats"}"""u8.ToArray(); + var pipeline = new RecordingPipeline(); + + using var subscriptionCancellation = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token); + var subscriptionTask = connection.SubscribeWithMessageValidationAsync( + subject, + pipeline, + ct: subscriptionCancellation.Token); + + MessageContext context; + try + { + await connection.PingAsync(timeout.Token); + await connection.PublishAsync(subject, payload, cancellationToken: timeout.Token); + await connection.PingAsync(timeout.Token); + context = await pipeline.WaitAsync(timeout.Token); + } + finally + { + await subscriptionCancellation.CancelAsync(); + try + { + await subscriptionTask; + } + catch (OperationCanceledException) when (subscriptionCancellation.IsCancellationRequested) + { + } + } + + Assert.Equal(subject, context.Source); + Assert.Equal(payload, context.RawPayload); + Assert.Equal(subject, context.Metadata["nats.subject"]); + } +} diff --git a/MessageValidation.IntegrationTests/RabbitMqIntegrationTests.cs b/MessageValidation.IntegrationTests/RabbitMqIntegrationTests.cs new file mode 100644 index 0000000..90ca85e --- /dev/null +++ b/MessageValidation.IntegrationTests/RabbitMqIntegrationTests.cs @@ -0,0 +1,45 @@ +using MessageValidation.RabbitMQ; +using RabbitMQ.Client; +using Testcontainers.RabbitMq; + +namespace MessageValidation.IntegrationTests; + +public sealed class RabbitMqIntegrationTests +{ + [Fact] + [Trait("Category", "Integration")] + public async Task PublishedMessage_ReachesValidationPipeline() + { + using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(5)); + await using var container = new RabbitMqBuilder("rabbitmq:4.1.8").Build(); + await container.StartAsync(timeout.Token); + + var connectionFactory = new ConnectionFactory + { + Uri = new Uri(container.GetConnectionString()) + }; + + await using var connection = await connectionFactory.CreateConnectionAsync(timeout.Token); + await using var channel = await connection.CreateChannelAsync(cancellationToken: timeout.Token); + + var queue = $"message-validation-{Guid.NewGuid():N}"; + await channel.QueueDeclareAsync( + queue, + durable: false, + exclusive: true, + autoDelete: true, + cancellationToken: timeout.Token); + + var pipeline = new RecordingPipeline(); + await channel.UseMessageValidation(pipeline, queue, ct: timeout.Token); + + var payload = """{"transport":"rabbitmq"}"""u8.ToArray(); + await channel.BasicPublishAsync(string.Empty, queue, payload, timeout.Token); + + var context = await pipeline.WaitAsync(timeout.Token); + + Assert.Equal(queue, context.Source); + Assert.Equal(payload, context.RawPayload); + Assert.Equal(queue, context.Metadata["rabbitmq.routingKey"]); + } +} diff --git a/MessageValidation.IntegrationTests/RecordingPipeline.cs b/MessageValidation.IntegrationTests/RecordingPipeline.cs new file mode 100644 index 0000000..033e2a9 --- /dev/null +++ b/MessageValidation.IntegrationTests/RecordingPipeline.cs @@ -0,0 +1,16 @@ +namespace MessageValidation.IntegrationTests; + +internal sealed class RecordingPipeline : IMessageValidationPipeline +{ + private readonly TaskCompletionSource _received = + new(TaskCreationOptions.RunContinuationsAsynchronously); + + public Task ProcessAsync(MessageContext context, CancellationToken ct = default) + { + _received.TrySetResult(context); + return Task.CompletedTask; + } + + public Task WaitAsync(CancellationToken ct) => + _received.Task.WaitAsync(ct); +} diff --git a/MessageValidation.slnx b/MessageValidation.slnx index 60127c2..b3e458e 100644 --- a/MessageValidation.slnx +++ b/MessageValidation.slnx @@ -16,6 +16,7 @@ + diff --git a/README.md b/README.md index 60b75bb..80fe4b7 100644 --- a/README.md +++ b/README.md @@ -196,6 +196,26 @@ public class MyDeadLetterHandler : IDeadLetterHandler | `IDeadLetterHandler` | Handles dead-lettered messages (receives `DeadLetterContext`) | | `IMessageMiddleware` | Composable pipeline stage (v2.0+) — see [Middleware pipeline](#middleware-pipeline-v20) | +## Testing + +Run the unit and in-process integration tests: + +```bash +dotnet test MessageValidation.slnx --filter "Category!=Integration" +``` + +The transport integration suite requires a running Docker engine and starts +RabbitMQ, Kafka, Mosquitto, NATS, Azure Service Bus, and Azure Event Hubs with +Testcontainers: + +```bash +dotnet test MessageValidation.IntegrationTests/MessageValidation.IntegrationTests.csproj --filter "Category=Integration" +``` + +The Azure emulator tests set `ACCEPT_EULA=Y` inside the required Service Bus, +Event Hubs, and SQL Server containers. Running them accepts the applicable +Microsoft container license terms. + ## Architecture The core library is **transport-agnostic** and **validation-framework-agnostic**. It defines contracts and a pipeline — adapters bring the implementations. From 41b6f7597cb90d078d22be06be096d4476bd28e1 Mon Sep 17 00:00:00 2001 From: "Dabadie, Romain" Date: Mon, 27 Jul 2026 14:21:25 -0400 Subject: [PATCH 2/2] test: fail fast on Service Bus processor errors Forward processor exceptions into the recording pipeline so infrastructure failures surface immediately instead of waiting for the integration timeout. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../AzureServiceBusIntegrationTests.cs | 6 +++++- .../RecordingPipeline.cs | 3 +++ .../RecordingPipelineTests.cs | 18 ++++++++++++++++++ 3 files changed, 26 insertions(+), 1 deletion(-) create mode 100644 MessageValidation.IntegrationTests/RecordingPipelineTests.cs diff --git a/MessageValidation.IntegrationTests/AzureServiceBusIntegrationTests.cs b/MessageValidation.IntegrationTests/AzureServiceBusIntegrationTests.cs index 63c5bf4..ca5f78a 100644 --- a/MessageValidation.IntegrationTests/AzureServiceBusIntegrationTests.cs +++ b/MessageValidation.IntegrationTests/AzureServiceBusIntegrationTests.cs @@ -68,7 +68,11 @@ public async Task Processor_ReceivesMessageThroughValidationPipeline() QueueName, new ServiceBusProcessorOptions { MaxConcurrentCalls = 1 }); var pipeline = new RecordingPipeline(); - processor.UseMessageValidation(pipeline); + processor.UseMessageValidation(pipeline, args => + { + pipeline.Fail(args.Exception); + return Task.CompletedTask; + }); var payload = """{"orderId":42}"""u8.ToArray(); MessageContext context; diff --git a/MessageValidation.IntegrationTests/RecordingPipeline.cs b/MessageValidation.IntegrationTests/RecordingPipeline.cs index 033e2a9..8b0dfdb 100644 --- a/MessageValidation.IntegrationTests/RecordingPipeline.cs +++ b/MessageValidation.IntegrationTests/RecordingPipeline.cs @@ -11,6 +11,9 @@ public Task ProcessAsync(MessageContext context, CancellationToken ct = default) return Task.CompletedTask; } + public void Fail(Exception exception) => + _received.TrySetException(exception); + public Task WaitAsync(CancellationToken ct) => _received.Task.WaitAsync(ct); } diff --git a/MessageValidation.IntegrationTests/RecordingPipelineTests.cs b/MessageValidation.IntegrationTests/RecordingPipelineTests.cs new file mode 100644 index 0000000..84dac41 --- /dev/null +++ b/MessageValidation.IntegrationTests/RecordingPipelineTests.cs @@ -0,0 +1,18 @@ +namespace MessageValidation.IntegrationTests; + +public sealed class RecordingPipelineTests +{ + [Fact] + public async Task Fail_CompletesWaitWithException() + { + var pipeline = new RecordingPipeline(); + var expected = new InvalidOperationException("processor failed"); + + pipeline.Fail(expected); + + var actual = await Assert.ThrowsAsync( + async () => await pipeline.WaitAsync(CancellationToken.None)); + + Assert.Same(expected, actual); + } +}