Moq Verify says method was never called, but it was

I have the following code which reads a Transaction from Kafka, and updates the account balance to show that transaction

public class KafkaConsumerService : BackgroundService
{
    private readonly IConsumer<string, Transaction> _kafkaConsumer;
    private readonly IRepository _repository;
    private readonly ICalculator _calculator;

    public KafkaConsumerService(
        IConsumer<string, Transaction> kafkaConsumer,
        IRepository repository,
        ICalculator calculator
    )
    {
        _kafkaConsumer = kafkaConsumer;
        _repository = repository;
        _calculator = calculator;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var consumeResult = await Task.Run(() => _kafkaConsumer.Consume(stoppingToken), stoppingToken);
        var transaction = consumeResult.Message.Value;

        var account = await _repository.GetAccount(transaction.Account);
        await _repository.UpdateAccount(_calculator.CalculateAccount(account, Normalize(transaction)));
    }

    private Transaction Normalize(Transaction transaction)
    {
        if (!transaction.IsCancellation)
        {
            return transaction;
        }

        return new Transaction(transaction)
        {
            Amount = transaction.Amount * -1,
            IsCancellation = false
        };
    }
}

I have then written the following unit test for this, using XUnit and Moq

public class KafkaConsumerServiceTest
{
    private readonly Mock<IConsumer<string, Transaction>> _kafka = new();
    private readonly Mock<IRepository> _repository = new();
    private readonly Mock<ICalculator> _calculator = new();

    private readonly Fixture _fixture = new();
    private readonly KafkaConsumerService _kafkaConsumerService;

    public KafkaConsumerServiceTest()
    {
        _kafkaConsumerService = new KafkaConsumerService(_kafka.Object, _repository.Object, _calculator.Object);
    }

    [Fact]
    public async Task KafkaConsumerService_ProcessesCancelationTransaction()
    {
        _fixture.Customize<Transaction>(composer => composer
            .With(transaction => transaction.IsCancellation, true)
        );

        var transaction = _fixture.Create<Transaction>();
        _kafka
            .Setup(consumer => consumer.Consume(It.IsAny<CancellationToken>()))
            .Returns(new ConsumeResult<string, Transaction>
            {
                Message = new Message<string, Transaction>
                {
                    Value = transaction,
                },
            });

        var result = _fixture.Create<Account>() with
        {
            AccountName = transaction.Account
        };

        _repository
            .Setup(repository => repository.GetAccount(transaction.Account))
            .ReturnsAsync(result);

        _calculator
            .Setup(calculator => calculator.CalculateAccount(It.IsAny<Account?>(), It.IsAny<Transaction>()))
            .Returns(result);

        await _kafkaConsumerService.StartAsync(CancellationToken.None);

        _repository.Verify(repository =>
            repository.GetAccount(transaction.Account)
        );
        _calculator.Verify(calculator =>
            calculator.CalculateAccount(result, transaction)
        );
        _repository.Verify(repository => repository.UpdateAccount(result));
    }
}

However I then get the following error

Moq.MockException

Expected invocation on the mock at least once, but was never performed: repository => repository.GetAccount("Account73ccea18-e39c-493f-9533-7af7f983b8ab")

Performed invocations:

   Mock<IRepository:1> (repository):

      IRepository.GetAccount("Account73ccea18-e39c-493f-9533-7af7f983b8ab")
      IRepository.UpdateAccount(Account { AccountName = Account73ccea18-e39c-493f-9533-7af7f983b8ab, Amount = 119 })

As you can see it says the method GetAccount("Account73ccea18-e39c-493f-9533-7af7f983b8ab") was never called, however right below it under Performed invocations, it says it was called.

If anyone has any ideas as to what is going wrong here I would appreciate it.

EDIT
Adding an await Task.Delay(100) on the unit tests seem to fix the problem, however this isnt an ideal solution, and I still dont understand why the issue occurs in the first place.

EDIT #2
It seems that removing the extension of BackgroundService (https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.backgroundservice?view=dotnet-plat-ext-7.0) seems to fix the test aswell. Could this somehow be causing a race condition in my code?

I think the culprit could be this:

return new Transaction(transaction)
{
    Amount = transaction.Amount * -1,
    IsCancellation = false
};

When you verify against an instance, it is doing a reference check so it cannot be a different newly made object.

Try

_repository.Verify(repository =>
    repository.GetAccount(It.IsAny<string>())
);
_repository.Verify(repository => repository.UpdateAccount(It.IsAny<Transaction>()));

You may also use It.Is<Transaction>(t => t.AccountName == "account") to validate specific values in the assertion.

Looking into this further. It appears that BackgroundService.StartAsync will call ExecuteAsync, and then return Task.CompletedTask

public virtual Task StartAsync(CancellationToken cancellationToken)
{
     // Store the task we're executing
    _executingTask = ExecuteAsync(_stoppingCts.Token);

    // If the task is completed then return it,
    // this will bubble cancellation and failure to the caller
    if (_executingTask.IsCompleted)
    {
        return _executingTask;
    }

    // Otherwise it's running
    return Task.CompletedTask;
}

This then meant that my code has not finished executing yet, hence why my moq assertions failed. I then assume that the timing between these two was very close, so that by the time the error was generated, the methods had been called hence the confusing error message.

I fixed this issue by simply waiting for the executed task to be completed

await _kafkaConsumerService.StartAsync(CancellationToken.None);
await _kafkaConsumerService.ExecuteTask;