Partial mock methods in a class using Autofixture, Moq and XUnit

Question

I want to mock only some methods of a class and call the real implementation for other methods.

I have my sut class Test where the Runner class is injected in the constructor. This injected class has again a injected other class RunnerParam in the constructor.

The code is a simplified case of my real classes in trying to have only the basics.

[Fact]
public void Test()
{
    var fixture = new Fixture().Customize(new AutoMoqCustomization());

    var paramMock = fixture.Freeze<Mock<IRunnerParam>>();
    paramMock.Setup(x => x.Multiplicator()).Returns(2);

    var classMock = fixture.Freeze<Mock<IRunner>>();
    classMock.Setup(x => x.Run()).Returns(5);

    var test = fixture.Create<Test>();

    var result = test.StartRunning();  // should be 5
    var result2 = test.StartRunningImplementation(5); // should be 500
}

Supporting members

public interface IRunnerParam
{
    int Multiplicator();
}

public class RunnerParam : IRunnerParam
{
    public virtual int Multiplicator()
    {
        return 20;
    }
}

public interface IRunner
{
    int Run();
    int RunImplementation(int param);
}

public class Runner : IRunner
{
    protected virtual RunnerParam MultiParam { get; set; }
    public Runner(RunnerParam multiParam)
    {
        MultiParam = multiParam;
    }

    public virtual int Run()
    {
        return 10;
    }

    public int RunImplementation(int param)
    {
        return 10 * MultiParam.Multiplicator() * param * Run();
    }
}

public class Test
{
    private readonly IRunner _runner;
    public Test(IRunner runner)
    {
        _runner = runner;
    }

    public int StartRunning()
    {
        return _runner.Run();
    }

    public int StartRunningImplementation(int param)
    {
        return _runner.RunImplementation(param);
    }
}

I want to mock and give a mocked value to the method Run in the class Runner, but to use the real implementation of the method RunImplementation.

I would expect to see for result2 500, but it's 0, meaning that the method is not seen as mocked up. In my eyes that is correct, but the Moq callbase is equal to true, so the real implementation should be taken, but it isn't.

What am I missing here?

Answer 1

In the shown simplified example, Test is only dependent on IRunner

private readonly IRunner _runner;
public Test(IRunner runner)
{
    _runner = runner;
}

So that is all that needs to be mocked if the intention was to test Test class in isolation.

//...

var classMock = fixture.Freeze<Mock<IRunner>>();
classMock.Setup(x => x.Run()).Returns(5);
classMock.Setup(x => x.RunImplementation(It.IsAny<int>())).Returns(500);

//...

If Runner class is to be also tested in isolation, then a mocked RunnerParam would be needed to satisfy its dependencies.

It should however be dependent on the abstraction (interface) and not the concretion (implementation).

protected virtual IRunnerParam MultiParam { get; set; }
public Runner(IRunnerParam multiParam) {
    MultiParam = multiParam;
}

This simplifies the isolated test as described in the original question

I want to mock and give a mocked value to the method Run in the class Runner, but to use the real implementation of the method RunImplementation.

//Arrange
var fixture = new Fixture().Customize(new AutoMoqCustomization());

var runnerParam = fixture.Freeze<Mock<IRunnerParam>>()
    .Setup(_ => _.Multiplicator())
    .Returns(2);

var subjectMock = fixture.Freeze<Mock<Runner>>();
subjectMock.CallBase = true;
subjectMock.Setup(_ => _.Run()).Returns(5);

int expected = 500;
Runner sut = subjectMock.Object;

//Act
var actual = sut.RunImplementation(5); // should be 500

//Assert
actual.Should().Be(expected);