Unit test RabbitMQ MessageProducer in an ASP.NET Core Web API

I have setup a MessageProducer with publisher confirms following the tutorial provided by RabbitMQ docs (https://www.rabbitmq.com/tutorials/tutorial-seven-dotnet.html).

I am using XUnit and NSubstitute for my tests, and I now struggle to unit-test the functionality of the callback function I've defined for the IModel _channel.

If I just test that the channel received the expected amounts of BasicPublish() the test runs to completion.

Here's my service method:

public async Task SendMessagesWithConfirmAsync<T>(IEnumerable<T> messages, string queueName, string routingKey)
{
    _channel.QueueDeclare(queueName, true, false);

    _channel.ConfirmSelect();

    // Register callbacks to handle acknowledgments
    _channel.BasicAcks += (sender, ea) => CleanOutstandingConfirms(ea.DeliveryTag, ea.Multiple);

    _channel.BasicNacks += (sender, ea) =>
        {
            _outstandingConfirms.TryGetValue(ea.DeliveryTag, out var body);

            Console.WriteLine(
                $"Message with body {body} has been nack-ed. Sequence number: {ea.DeliveryTag}, multiple: {ea.Multiple}");

            CleanOutstandingConfirms(ea.DeliveryTag, ea.Multiple);
    };

    foreach (var message in messages)
    {
        var body = JsonSerializer.Serialize(message);
        _outstandingConfirms.TryAdd(_channel.NextPublishSeqNo, body);
        _channel.BasicPublish(queueName, routingKey, null, Encoding.UTF8.GetBytes(body));
    }

    await Task.CompletedTask;
}

And in my unit test I want to make sure the callback events are correctly triggered

[Theory]
[InlineData("Test 1", "Test 2", "Test 3")]
public async void SendMessageWithConfirm_MultipleMessages_ShouldPublishMessagesAndWaitForConfirmOrDie(
    params string[] messages)
{
    // Arrange
    var messageProducer = new RabbitMqMessageProducer(_connectionFactory);

    // Act
    await messageProducer.SendMessagesWithConfirmAsync(messages, "invitations", "invitation");

    // Assert
    _channel.Received(messages.Length).BasicPublish(Arg.Any<string>(), Arg.Any<string>(),
        null, Arg.Any<ReadOnlyMemory<byte>>());

    // Assert on callback events
    // ...
}

Another thing is that the _channel.NextPublishSeqNo never gets incremented.

Any help or derivation to the correct documentation here would be much appreciated.

A unit test for rabbit should not check the rabbit server at all.
FOr rabbitMQ server you should add integration tests.

In unit test, you check YOUR code, so you have to add mocks that mock the rabbit MQ server.

I used Xunit nuget for the unit tests, and moq nuget for mocking the rabbitMQ like so:

Unit Test:

[Fact]
public void publish__exchange_declare()
{
      //Arange
      var rabbitMQMoq = new RabbitMQMoq();

      //Act
      var pubRequest = rabbitMQMoq.Publish(new MockEvent());

       //Assert
       rabbitMQMoq.DefaultChannel.Verify(m => m.ExchangeDeclare(pubRequest.ExchangeName, pubRequest.ExchangeType.ToString().ToLower(), pubRequest.Durable, false, null));
}

Mock:

  internal class RabbitMQMoq
    {
        #region consts

        public const string EXCHANGE_NAME = "TEST";
        public const string DLX_EXCHANGE_NAME = "DLX_TEST";
        public const string QUEUE_NAME = "TEST";
        public const string DLX_QUEUE_NAME = "DLX_TEST";
        public const string ROUTING_KEY = "TEST";
        public const string CONSUMER_TAG = "1234";
        public const ExchangeType EXCHNAGE_TYPE = ExchangeType.Topic;

        #endregion

        #region properties
        public Mock<IModel> DefaultChannel { get; private set; }
        public Mock<MockEventHandler> EventHandler { get; private set; }
        public Dictionary<string, IAsyncBasicConsumer> Consumers { get; private set; }
        public MojRabbitMQBus Bus { get; private set; }

        #endregion

        #region c-tor

        public RabbitMQMoq(HostConfiguration hostConfiguration= null)
        {
            DefaultChannel = new Mock<IModel>();
            Consumers = new Dictionary<string, IAsyncBasicConsumer>();
            EventHandler = new Mock<MockEventHandler>();
            Bus = CreateRabbitMQBService(hostConfiguration ?? DefaultHostConfiguration);
        }

  public PublishExchangeRequest<MockEvent> Publish(MockEvent mockEvent, PublishExchangeRequest<MockEvent> request = null)
        {
            var pubRequest = request ?? CreatePublishExchangeRequest(mockEvent);

            Bus.Publish(pubRequest);

            return pubRequest;
        }

 private Mock<IServiceScopeFactory> CreateServiceScopeFactory()
        {
            var serviceProvider = new Mock<IServiceProvider>();
            serviceProvider
          .Setup(x => x.GetService(typeof(MockEventHandler)))
          .Returns(EventHandler.Object);
            var serviceScope = new Mock<IServiceScope>();
            serviceScope.Setup(x => x.ServiceProvider).Returns(serviceProvider.Object);
            var serviceScopeFactory = new Mock<IServiceScopeFactory>();
            serviceScopeFactory
                .Setup(x => x.CreateScope())
                .Returns(serviceScope.Object);
            return serviceScopeFactory;
        }
}