如何获取在模拟类内部调用的方法的结果

Question

There is a way to get the result returned from a method called into a mocked object?

For example, if I have the following classes and an interface:

DoSomethingClass.cs

public class DoSomethingClass
{
  
  IInternalClass _intClass;

  public DoSomethingClass(IInternalClass intClass)
  {
    _intClass = intClass;
  }
  
  void DoSomething(int number)
  {
    // do some transformation to the number, e.g.
    var transformedNumber = number * (number - 1);
    
    var x = _intClass.IsEven(transformedNumber);

    // do something else
  }
}

InternalClass.cs

public interface IInternalClass
{
  bool IsEven(int number);
}

public class InternalClass: IInternalClass
{
  
  public InternalClass();
  
  public bool IsEven(int number)
  {
    return number % 2 == 0;
  }
}

And a test class:

Tests.cs

public class Tests
{
  [Fact]
    public async Task test_something()
    {

        //PREPARE
        var request = 10

        var internalMock = new Mock<IInternalClass>();
        var classToTest = new DoSomethingClass(internalMock.Object);

        // ACT

        await classToTest.DoSomething(request);

        //ASSERT

        //Here I want to check if the method IsEven of the internal class return the right result
    }
  }
}

What I want to assert is the return value of the method IsEven of the InternalClass called inside the main method DoSomething , there is no way that I can know the transformedNumber calculated inside this method and passed to IsEven .

NOTE: I use the Moq library to mock object.

Excuse me for the stupid example above, but I don't have any simple real code to show here, however I hope this can be sufficient to understand the question.

Answer 1

I am assuming that you want to verify that your IsEven method is called on the mocked IInternalClass?

If that is the case then you can use the Verify method on the mock as follows:

[Fact]
public void DoSomething_Verify()
{
    var request = 10;
    var internalMock = new Mock<IInternalClass>();
    var classToTest = new DoSomethingClass(internalMock.Object);

    classToTest.DoSomething(request);

    //Verify that the mock is invoked with the expected value, the expected number of times
    internalMock.Verify(v => v.IsEven(90), Times.Once);
    //There are lots of other options for Times, e.g. it is never called with an unexpected value maybe.
    internalMock.Verify(v => v.IsEven(91), Times.Never);
}

Also to call the DoSomething method with await you would need to change the method signature as follows:

public async Task DoSomethingAsync(int number)
{
    // do some transformation to the number, e.g.
    var transformedNumber = number * (number - 1);

    var x = _intClass.IsEven(transformedNumber);

    // do something else
}

Then you can create a unit test like this:

[Fact]
public async void DoSomething_VerifyAsync()
{
    var request = 10;
    var internalMock = new Mock<IInternalClass>();
    var classToTest = new DoSomethingClass(internalMock.Object);

    //To call the DoSomething method with await the method needs the async Task and a good convention is to append Async to the name
    await classToTest.DoSomethingAsync(request);

    //Another slightly more generic option is to verify that the mock was called with and int exactly n Times
    internalMock.Verify(v => v.IsEven(It.IsAny<int>()), Times.Exactly(1));
}