不使用 Mock.Setup() 调用 Mock.Returns()

Question

When using Moq, you often need to configure your mock to return specific values. To specify what you want to return, you have to go through the routine of defining Setup() with following structure before you get to define what your method should return:

var o = new ObjectToReturn();

myMock.Setup(m => m.MyMethod(It.IsAny<T1>()...It.IsAny<Tn>()))
      .Returns(o);

Instead, I would like to do "For methods with this name, return this value", something like:

myMock.Setup(m => m.GetType().GetMethod("MyMethod")).Returns(o);

or

myMock.Setup("MyMethod").Return(o);

Is there any other way to skip this verbose enumeration of all method parameters when I don't care about types, values or number of parameters at all?

I know there is a method SetReturnsDefault() but I don't want to setup default values for all the methods of the mock.

Answer 1

This is possible. Try:

public interface IService
{
    int MyMethod1(int a, object b);

    int MyMethod2(int a);
    int MyMethod2(object b);
}

public static class MyMockExtensions
{
    public static ISetup<T, TResult> Setup<T, TResult>(this Mock<T> mock, 
        string methodName) where T : class
    {
        var methods = typeof(T).GetMethods()
            .Where(
                mi => mi.Name == methodName
                && mi.ReturnType == typeof(TResult))
            .ToArray();

        if (methods.Length == 0)
        {
            throw new MissingMethodException("No method found.");
        }

        if (methods.Length > 1)
        {
            throw new AmbiguousMatchException("Ambiguous methods found.");
        }

        var method = methods[0];

        // Figure out parameters.
        var parameters = method.GetParameters()
            // It.IsAny<pi.ParameterType>()
            .Select(pi => Expression.Call(
                typeof(It), nameof(It.IsAny), new[] { pi.ParameterType }));

        // arg0 => arg0.MyMethod(It.IsAny<T1>()...It.IsAny<Tn>())
        var arg0 = Expression.Parameter(typeof(T), "arg0");
        var setupExpression = Expression.Lambda<Func<T, TResult>>(
            Expression.Call(arg0, method, parameters), arg0);

        return mock.Setup(setupExpression);
    }
}

Usage:

var mock = new Mock<IService>();

mock.Setup<IService, int>("MyMethod1").Returns(123);
// method1Result = 123
var method1Result = mock.Object.MyMethod1(1, 2);

// This throws AmbiguousMatchException exception as there are two MyMethod3
// both returning an integer.
mock.Setup<IService, int>("MyMethod2").Returns(234);

The challenge would be dealing with different types of methods defined by your mocked type:

• Normal method
• Generic method
• Method overloading

Answer 2

The default value provider is potentially an option. This isn't the same as SetReturnsDefault , you've got a lot more control.

A real quick MVP default value provider such as the following:

public class SelectiveDefaultValueProvider : DefaultValueProvider
{
    private readonly string _methodName;
    private readonly object _returns;

    public SelectiveDefaultValueProvider(string methodName, object returns)
    {
        _methodName = methodName;
        _returns = returns;
    }

    protected override object GetDefaultValue(Type type, Mock mock)
    {
        var lastInvocation = mock.Invocations.Last();
        var methodInfo = lastInvocation.Method;
        var args = lastInvocation.Arguments;

        if (methodInfo.Name.Equals(_methodName))
        {
            return _returns;
        }

        return type.IsValueType ? Activator.CreateInstance(type) : null;
    }
}

...allows you to inject some decision making before the value is returned. In this case I'm checking the last invocation method name, if it's a match I'm returning the nominated object to return. I'm not using the args variable but I've included it to show that you've not only got the MethodInfo of the last invocation, but also the provided arguments. Enough to make clever decisions.

Take the following interface with a few overloaded methods and the same return type:

public class ObjectToReturn
{
    public Guid Id { get; set; }
}

public interface IFoo
{
    ObjectToReturn MyMethod(int parameter1);

    ObjectToReturn MyMethod(string parameter2);

    ObjectToReturn MyMethod(int parameter1, int parameter2);

    ObjectToReturn AnotherMethod();

    int AValueTypeMethod();
}

The test setup would look like

[Test]
public void DefaultValueProvider_ForOverloadedMethod_AllOverloadsReturnSameExpectedResult()
{
    var objectToReturn = new ObjectToReturn { Id = Guid.NewGuid() };
    var mock = new Mock<IFoo> { DefaultValueProvider = new SelectiveDefaultValueProvider(nameof(IFoo.MyMethod), objectToReturn) };
    var mocked = mock.Object;

    var result1 = mocked.MyMethod(1);
    var result2 = mocked.MyMethod(1, 2);
    var result3 = mocked.MyMethod("asdf");
    var result4 = mocked.AnotherMethod();
    var result5 = mocked.AValueTypeMethod();

    Assert.Multiple(() =>
    {
        Assert.That(result1, Is.SameAs(objectToReturn));
        Assert.That(result2, Is.SameAs(objectToReturn));
        Assert.That(result3, Is.SameAs(objectToReturn));
        Assert.That(result4, Is.Null);
        Assert.That(result5, Is.TypeOf<int>());
    });
}

As mentioned the above is MVP, you could easily extend the default value provider implementation to take a list of methods/return values, tighten up the interface from string method names to MethodInfo results ( typeof(IFoo).GetMethods().Where(x => x.Name.StartsWith("MyMethod") && x.ReturnType == typeof(ObjectToReturn)) ) and so on.

The nice thing about this methodology is you don't have to worry about building Setup expressions and the headaches that that brings, and if you do specify a setup for a member it'll use that setup; the default value provider is only used for members that haven't had a setup specified.

Working solution