Illustration for how to use the Service Bus emulator in a C# test fixture

Test.cs

// This code was auto-generated by xRegistry CLI


#nullable enable

using System;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Threading;
using Azure.Messaging.ServiceBus;
using Xunit;
using Microsoft.Extensions.Logging;
using DotNet.Testcontainers.Containers;
using DotNet.Testcontainers.Builders;
using DotNet.Testcontainers.Networks;

namespace Lbsb1.Test
{
    public class Lbsb1Fixture : IAsyncLifetime
    {
        public IContainer? EmulatorContainer { get; protected set; }
        public IContainer? SqlEdgeContainer { get; protected set; }
        public INetwork? Network { get; protected set; }
        public string? ServiceBusConnectionString { get; protected set; }
        private ILoggerFactory _loggerFactory;
        private ILogger _logger;

        public ILoggerFactory GetLoggerFactory()
        {
            return _loggerFactory;
        }

        private string? emulatorConfigFilePath = null;
        private const string emulatorConfig = @"{
            ""UserConfig"": {
                ""Namespaces"": [
                    {
                        ""Name"": ""sbemulatorns"",
                        ""Queues"": [
                            {
                                ""Name"": ""myqueue"",
                                ""Properties"": {
                                    ""DeadLetteringOnMessageExpiration"": false,
                                    ""DefaultMessageTimeToLive"": ""PT1H"",
                                    ""LockDuration"": ""PT1M"",
                                    ""MaxDeliveryCount"": 10,
                                    ""RequiresDuplicateDetection"": false,
                                    ""RequiresSession"": false
                                }
                            }
                        ]
                    }
                ],
                ""Logging"": {
                    ""Type"": ""File""
                }
            }
        }";

        public Lbsb1Fixture()
        {
            _loggerFactory = LoggerFactory.Create(builder =>
            {
                builder.AddDebug().AddConsole();
            });
            _logger = _loggerFactory.CreateLogger<Lbsb1Fixture>();
        }

        public async Task InitializeAsync()
        {
            try
            {
                Network = new NetworkBuilder()
                    .WithName(Guid.NewGuid().ToString("D"))
                    .Build();

                emulatorConfigFilePath = Path.GetTempFileName();
                File.WriteAllText(emulatorConfigFilePath, emulatorConfig);

                SqlEdgeContainer = new ContainerBuilder()
                    .WithImage("mcr.microsoft.com/azure-sql-edge:latest")
                    .WithEnvironment("ACCEPT_EULA", "Y")
                    .WithEnvironment("MSSQL_SA_PASSWORD", "StrongPassword!1")
                    .WithNetwork(Network)
                    .WithNetworkAliases("sqledge")
                    .WithWaitStrategy(Wait.ForUnixContainer().UntilPortIsAvailable(1431))
                    .Build();

                EmulatorContainer = new ContainerBuilder()
                    .WithImage("mcr.microsoft.com/azure-messaging/servicebus-emulator:latest")
                    .WithBindMount(emulatorConfigFilePath, "/ServiceBus_Emulator/ConfigFiles/Config.json")
                    .WithPortBinding(5672, false)
                    .WithNetwork(Network)
                    .WithNetworkAliases("sb-emulator")
                    .WithEnvironment("SQL_SERVER", "sqledge")
                    .WithEnvironment("MSSQL_SA_PASSWORD", "StrongPassword!1")
                    .WithEnvironment("ACCEPT_EULA", "Y")
                    .WithWaitStrategy(Wait.ForUnixContainer().UntilMessageIsLogged(".*Emulator Service is Successfully Up!"))
                    .Build();

                await Network.CreateAsync();
                await SqlEdgeContainer.StartAsync();
                await EmulatorContainer.StartAsync();
                
                await Task.Delay(5000); // Wait for emulator to be settled

                ServiceBusConnectionString = "Endpoint=sb://localhost;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=SAS_KEY_VALUE;UseDevelopmentEmulator=true;";
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "An error occurred during InitializeAsync");
                throw;
            }
        }

        public async Task DisposeAsync()
        {
            try
            {
                if (EmulatorContainer != null)
                {
                    await EmulatorContainer.StopAsync();
                }

                if (SqlEdgeContainer != null)
                {
                    await SqlEdgeContainer.StopAsync();
                }

                if (Network != null)
                {
                    await Network.DeleteAsync();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred during DisposeAsync: {ex.Message}");
            }
            finally
            {
                if (emulatorConfigFilePath != null && File.Exists(emulatorConfigFilePath))
                {
                    File.Delete(emulatorConfigFilePath);
                }
            }
        }
    }

    [CollectionDefinition("Service Bus emulator")]
    public class Lbsb1CollectionFixture : ICollectionFixture<Lbsb1Fixture>
    {
    }
    [Collection("Service Bus emulator")]
    public class Lbsb1FabrikamLumenProducerTests 
    {
        private readonly Lbsb1Fixture _fixture;
        private readonly ILogger _logger;
        private readonly ServiceBusSender _sender;
        private readonly ServiceBusClient _client;

        public Lbsb1FabrikamLumenProducerTests(Lbsb1Fixture fixture)
        {
            _fixture = fixture;
            _logger = _fixture.GetLoggerFactory().CreateLogger<Lbsb1FabrikamLumenProducerTests>();
            _client = new ServiceBusClient(_fixture.ServiceBusConnectionString);
            _sender = _client.CreateSender("myqueue"); // Adjust based on queue/topic naming convention
        }

#pragma warning disable CS8604 // init takes care of nullables
        [Fact]
        public async Task TestTurnedOnMessage()
        {
            _logger.LogInformation("Starting TestTurnedOnMessage");
            try
            {
                var eventDataInstance = new global::Lbsb1Data.Fabrikam.Lumen.TurnedOnEventDataTests().CreateInstance();
                var message = new ServiceBusMessage(eventDataInstance.ToString()); // Serialize if needed

                await _sender.SendMessageAsync(message);
                _logger.LogInformation("Test message for TurnedOn sent.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "An error occurred during TestTurnedOnMessage");
                throw;
            }
        }

        [Fact]
        public async Task TestTurnedOnBatch()
        {
            _logger.LogInformation("Starting TestTurnedOnBatch");
            try
            {
                var eventDataTest = new global::Lbsb1Data.Fabrikam.Lumen.TurnedOnEventDataTests();
                var eventDataInstances = new ServiceBusMessage[10];
                for (int i = 0; i < 10; i++)
                {
                    var instance = eventDataTest.CreateInstance();
                    eventDataInstances[i] = new ServiceBusMessage(instance.ToString()); // Serialize if needed
                }

                using ServiceBusMessageBatch messageBatch = await _sender.CreateMessageBatchAsync();
                foreach (var eventData in eventDataInstances)
                {
                    if (!messageBatch.TryAddMessage(eventData))
                    {
                        throw new InvalidOperationException("Message too large for batch");
                    }
                }

                await _sender.SendMessagesAsync(messageBatch);
                _logger.LogInformation("Batch of messages for TurnedOn sent.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "An error occurred during TestTurnedOnBatch");
                throw;
            }
        }
        [Fact]
        public async Task TestTurnedOffMessage()
        {
            _logger.LogInformation("Starting TestTurnedOffMessage");
            try
            {
                var eventDataInstance = new global::Lbsb1Data.Fabrikam.Lumen.TurnedOffEventDataTests().CreateInstance();
                var message = new ServiceBusMessage(eventDataInstance.ToString()); // Serialize if needed

                await _sender.SendMessageAsync(message);
                _logger.LogInformation("Test message for TurnedOff sent.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "An error occurred during TestTurnedOffMessage");
                throw;
            }
        }

        [Fact]
        public async Task TestTurnedOffBatch()
        {
            _logger.LogInformation("Starting TestTurnedOffBatch");
            try
            {
                var eventDataTest = new global::Lbsb1Data.Fabrikam.Lumen.TurnedOffEventDataTests();
                var eventDataInstances = new ServiceBusMessage[10];
                for (int i = 0; i < 10; i++)
                {
                    var instance = eventDataTest.CreateInstance();
                    eventDataInstances[i] = new ServiceBusMessage(instance.ToString()); // Serialize if needed
                }

                using ServiceBusMessageBatch messageBatch = await _sender.CreateMessageBatchAsync();
                foreach (var eventData in eventDataInstances)
                {
                    if (!messageBatch.TryAddMessage(eventData))
                    {
                        throw new InvalidOperationException("Message too large for batch");
                    }
                }

                await _sender.SendMessagesAsync(messageBatch);
                _logger.LogInformation("Batch of messages for TurnedOff sent.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "An error occurred during TestTurnedOffBatch");
                throw;
            }
        }
        [Fact]
        public async Task TestBrightnessChangedMessage()
        {
            _logger.LogInformation("Starting TestBrightnessChangedMessage");
            try
            {
                var eventDataInstance = new global::Lbsb1Data.Fabrikam.Lumen.BrightnessChangedEventDataTests().CreateInstance();
                var message = new ServiceBusMessage(eventDataInstance.ToString()); // Serialize if needed

                await _sender.SendMessageAsync(message);
                _logger.LogInformation("Test message for BrightnessChanged sent.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "An error occurred during TestBrightnessChangedMessage");
                throw;
            }
        }

        [Fact]
        public async Task TestBrightnessChangedBatch()
        {
            _logger.LogInformation("Starting TestBrightnessChangedBatch");
            try
            {
                var eventDataTest = new global::Lbsb1Data.Fabrikam.Lumen.BrightnessChangedEventDataTests();
                var eventDataInstances = new ServiceBusMessage[10];
                for (int i = 0; i < 10; i++)
                {
                    var instance = eventDataTest.CreateInstance();
                    eventDataInstances[i] = new ServiceBusMessage(instance.ToString()); // Serialize if needed
                }

                using ServiceBusMessageBatch messageBatch = await _sender.CreateMessageBatchAsync();
                foreach (var eventData in eventDataInstances)
                {
                    if (!messageBatch.TryAddMessage(eventData))
                    {
                        throw new InvalidOperationException("Message too large for batch");
                    }
                }

                await _sender.SendMessagesAsync(messageBatch);
                _logger.LogInformation("Batch of messages for BrightnessChanged sent.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "An error occurred during TestBrightnessChangedBatch");
                throw;
            }
        }
        [Fact]
        public async Task TestColorChangedMessage()
        {
            _logger.LogInformation("Starting TestColorChangedMessage");
            try
            {
                var eventDataInstance = new global::Lbsb1Data.Fabrikam.Lumen.ColorChangedEventDataTests().CreateInstance();
                var message = new ServiceBusMessage(eventDataInstance.ToString()); // Serialize if needed

                await _sender.SendMessageAsync(message);
                _logger.LogInformation("Test message for ColorChanged sent.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "An error occurred during TestColorChangedMessage");
                throw;
            }
        }

        [Fact]
        public async Task TestColorChangedBatch()
        {
            _logger.LogInformation("Starting TestColorChangedBatch");
            try
            {
                var eventDataTest = new global::Lbsb1Data.Fabrikam.Lumen.ColorChangedEventDataTests();
                var eventDataInstances = new ServiceBusMessage[10];
                for (int i = 0; i < 10; i++)
                {
                    var instance = eventDataTest.CreateInstance();
                    eventDataInstances[i] = new ServiceBusMessage(instance.ToString()); // Serialize if needed
                }

                using ServiceBusMessageBatch messageBatch = await _sender.CreateMessageBatchAsync();
                foreach (var eventData in eventDataInstances)
                {
                    if (!messageBatch.TryAddMessage(eventData))
                    {
                        throw new InvalidOperationException("Message too large for batch");
                    }
                }

                await _sender.SendMessagesAsync(messageBatch);
                _logger.LogInformation("Batch of messages for ColorChanged sent.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "An error occurred during TestColorChangedBatch");
                throw;
            }
        }
    }
}