Moq checking if method is called with parameter from another call

Question

I have the following function that I am trying to put under unit test

public MessageListDto GetMessageList(SimpleSearchCriteria criteria)
{
    var messages = _repository.GetMessages(criteria, out int total);
    return new MessageListDto(messages, total);
}        

and the following is my test so far, in which I am able to determine that _repository.GetMessages is call with the correct parameters.

However, how do I test that the second line is tested properly, I need to test that

• A new object of type MessageListDto is constructed with the two parameters returned from the line above
• the newly constructed object is returned

[Test]
public void Test1()
{
    int total = 10;
    var searchCriteria = new SimpleSearchCriteria();
    var mockRepo = new Mock<IMessageRepository>();
    var messageService = new MessageService(mockRepo.Object);
    messageService.GetMessageList(searchCriteria);
    mockRepo.Verify(r => r.GetMessages(searchCriteria, out total), Times.Once);
    mockRepo.Verity ??????????
}        

Answer 1

As we have discussed in the comment section your goal is to test the returned messages is passed to the dto's constructor without any modification.

With your current code you can't do that because you are creating the DTO explicitly inside your method. So, you can't replace it with a spy.

Just to clarify some terminologies:

• Dummy: simple code that returns bogus data
• Fake: a working alternative which can take shortcuts
• Stub: custom logic with predefined data
• Mock: custom logic with expectations (interactive stub)
• Shim: custom logic at run-time
• Spy: interceptors to record calls

To be able to capture the arguments of the MessageListDto constructor call you need to introduce an other layer between your GetMessageList method and the constructor. (In other words indirection)

---

For the sake of simplicity let me assume that IMessageRepository's GetMessages returns a string array.

So, you can introduce an interface like this:

public interface IDtoProvider
{
    public MessageListDto CreateMessageList(string[] messages, int total)
        => new MessageListDto(messages, total);
}

• Here I have used C# 8's interface default implementation feature
• It can be further shortened with C# 9's target-typed new expression feature
• If you are using older C# version then you need to separate the interface and the default implementation from each other

Now lets amend your MessageService to receive a IDtoProvider instance via its constructor

class MessageService
{
    private readonly IMessageRepository _repository;
    private readonly IDtoProvider _dtoProvider;
    public MessageService(IMessageRepository repository, IDtoProvider dtoProvider)
        => (_repository, _dtoProvider) = (repository, dtoProvider);

    public MessageListDto GetMessageList(SimpleSearchCriteria criteria)
    {
        var messages = _repository.GetMessages(criteria, out int total);
        return _dtoProvider.CreateMessageList(messages, total);
    }
    ...
}

• Here I've took advantage of ValueTuple's deconstruct capability

---

With these in our hand we can write a unit test like this:

//Arrange - Repo
string[] messages = new[] { "OnlyElement" };
int total = 10;
var mockRepo = new Mock<IMessageRepository>();
mockRepo
    .Setup(repo => repo.GetMessages(It.IsAny<SimpleSearchCriteria>(), out total))
    .Returns(messages);

//Arrange - Provider
var dto = new MessageListDto(messages, total);
string[] messagesArgument = null;
int totalArgument = -1;
var mockProvider = new Mock<IDtoProvider>();
mockProvider
    .Setup(provider => provider.CreateMessageList(It.IsAny<string[]>(), It.IsAny<int>()))
    .Callback<string[], int>((messages, total) => (messagesArgument, totalArgument) = (messages, total))
    .Returns(dto);


//Arrange - SUT
var searchCriteria = new SimpleSearchCriteria();
var sut = new MessageService(mockRepo.Object, mockProvider.Object);

//Act
sut.GetMessageList(searchCriteria);

//Assert - Repo
mockRepo.Verify(r => r.GetMessages(searchCriteria, out total), Times.Once);

//Assert - Provider
Assert.Equal(messages, messagesArgument);
Assert.Equal(total, totalArgument);

1. I've defined how should the IMessageRepository mock behave
2. I've defined how should the IDtoProvider mock behave
   2.1 I've used here the Callback method to capture the calling argument
   2.2 If you perform multiple calls against your mocked method then please consider to use Capture.In
3. I've instantiated a MessageService (which is our system under test) with the mock objects
4. I've called the GetMessageList inside the Act phase
5. I've made assertion against the repo mock call
6. I've made assertion against the calling parameters of the CreateMessageList
   6.1 Here I have used xunit's assertion

Answer 2

The first step is to setup the MessageService mock, so that it returns something deterministic and then in the second step you verify that that has been used to construct your MessageListDto.

[Test]
public void Test1()
{
    // arrange
    int total = 10;
    var searchCriteria = new SimpleSearchCriteria();
    var messages = new [] {"message1", "message2"} // or similar
    var mockRepo = new Mock<IMessageRepository>();
// or similar, I am not quite certain as to the specific syntax. Especially wrt. out parameters. Check the documentation. 
    mockRepo.Setup(x => x.GetMessages(It.IsAny<SimpleSearchCriteria>(), It.IsAny<int>())).Returns(messages); 
    var messageService = new MessageService(mockRepo.Object);           

    // act
    var result = messageService.GetMessageList(searchCriteria);

    // assert
    mockRepo.Verify(r => r.GetMessages(searchCriteria, out total), Times.Once);
    // or similar; here you might want to check out FluentAssertions as @Peter Csala suggested
    Assert.Equal(result.Messages, messages); 
}    

Answer 3

What's missing from previous answers is that whenever possible, you should set up the mocked method with the exact parameters, that you expect it to receive. In other words set up the method with concrete values instead of It.IsAny<>(). In such case you won't have to verify the method later at all. (Unless it's critical to test, how many times a method is called). Simply, if mocked GetMessages receives different arguments than expected, it will return null, set total to 0 and your test will fail. Having the mocked methods set up properly, you can now focus on verifying what GetMessageList returns, which is the purpose of this unit test.

[Test]
public void Test1()
{
    int total = 10;
    var messages = new[] {new Message()};
    var searchCriteria = new SimpleSearchCriteria();
    var mockRepo = new Mock<IMessageRepository>();
    mockRepo.Setup(_ => _.GetMessages(searchCriteria, out total))
        .Returns(messages);
    var messageService = new MessageService(mockRepo.Object);
    var dto = messageService.GetMessageList(searchCriteria);
    Assert.AreSame(messages, dto.Messages);
    Assert.AreEqual(total, dto.Total);
}