我想编写一个测试，该测试肯定会告诉您是否调用了模拟方法

Question

I have a method:

public class CreateNewAccountUseCase
{
    private readonly IAccountRepository _accountRepository;

    public CreateNewAccountUseCase(IAccountRepository accountRepository)
    {
        _accountRepository = accountRepository;
    }

    public virtual async Task Execute(Account account)
    {
       await _accountRepository.Create(account);
    }
}

I use it in the controller:

public async Task<ActionResult<AccountModel>>  CreateAccount([FromBody]CreatingAccount creatingAccount)
{
    var account = creatingAccount.ConvertToAccount();

    await _createNewAccountUseCase.Execute(account);

    return Created($"/accounts/{account.Id}", account);
}

I want to be sure that the UseCase method will be exactly called.

I wrote this controller test:

[Fact]
public async Task Create()
{
    // arrange
    var account = new CreatingAccount();

    var accountRepository = new Mock<IAccountRepository>();
    var createNewAccountUseCase = new Mock<CreateNewAccountUseCase>(accountRepository.Object);

    createNewAccountUseCase.Setup(m => m.Execute(account)).Returns(Task.CompletedTask);

    // act
    await controller.CreateAccount(account);
    // assert
    createNewAccountUseCase.Verify(m => m.Execute(account), Times.Once);
}

I expect createNewAccountUseCase.Verify() to check if the method has been method but I get failed test with a message:

Moq.MockException : 
Expected invocation on the mock once, but was 0 times: m => m.Execute(account)

Performed invocations:
Mock<CreateNewAccountUseCase:1> (m):
No invocations performed.

How do I make sure the method (createNewAccountUseCase.Verify()) is called?

Answer 1

You are mocking the subject under test. Instead mock the dependency and invoked the method under test

[Fact]
public async Task Create() {
    // arrange
    var account = new CreatingAccount();

    var accountRepository = new Mock<IAccountRepository>();
    accountRepository.Setup(m => m.Create(It.IsAny<Account>())).Returns(Task.CompletedTask);

    var createNewAccountUseCase = new CreateNewAccountUseCase(accountRepository.Object);

    // act
    await createNewAccountUseCase.Execute(account.ConvertToAccount());

    // assert
    accountRepository.Verify(m => m.Create(It.IsAny<Account>()), Times.Once);
}

The assertion can then be done on the repository mock to verify that the method behaves as expected.

In the controller test of your question you could have used the mock use case but your also need to make sure that it was injected into the controller.

But your example showed no such injection.

The following example creates the controller and explicitly injects the dependency

[Fact]
public async Task Create() {
    // arrange
    var account = new CreatingAccount();

    var accountRepository = new Mock<IAccountRepository>();
    accountRepository.Setup(m => m.Create(It.IsAny<Account>())).Returns(Task.CompletedTask);
    var createNewAccountUseCase = new CreateNewAccountUseCase(accountRepository.Object);

    var controller = new MyController(createNewAccountUseCase);

    // act
    await controller.CreateAccount(account);

    // assert
    accountRepository.Verify(m => m.Create(It.IsAny<Account>()), Times.Once);
}