使用表达式为方法设置模拟

Question

I'm trying to setup a mocked return value for a method. I know the classic way of doing it, but I want to do it by creating Expression objects explicitly. Here is what I have tried so far:

using Moq;
using NUnit.Framework;
using System;
using System.Linq.Expressions;

namespace MoqTest
{
    public interface IBlah
    {
        string DoStuff(string x);
    }

    public class SomeProgram
    {
        static void Main(string[] args)
        {
            Mock<IBlah> m = new Mock<IBlah>(MockBehavior.Strict);

            //I want to do the equivalent of this:
            //m.Setup(a => a.DoStuff(It.IsAny<string>())).Returns("mocked!");

            var method = typeof(IBlah).GetMethod("DoStuff", new Type[] { typeof(string) });
            ParameterExpression parameterForDoStuff = Expression.Parameter(typeof(string), "x");
            ParameterExpression thisParameter = Expression.Parameter(typeof(IBlah), "someIBlahInstance");
            MethodCallExpression methodCall = Expression.Call(thisParameter, method, new[] { parameterForDoStuff });
            Expression<Func<IBlah, string>> lambdaExpression = Expression.Lambda<Func<IBlah, string>>(methodCall, new ParameterExpression[] { parameterForDoStuff });
            //above line fails: Unhandled Exception: System.ArgumentException: ParameterExpression of type 'System.String' cannot be used for delegate parameter of type 'MoqTest.IBlah'

            m.Setup(lambdaExpression).Returns("mocked!");

            Assert.AreEqual("mocked!", m.Object.DoStuff(string.Empty));
        }
    }
}

As you can see, I'm confused when it comes to the lambdaExpression - should I be creating one that represents a Func<string,string> (for the IBlah.DoStuff method), or should I be creating a Func<IBlah,string> (representing the lambda parameter for the Mock.Setup method)? I put the equivalent setup that I want to do in a comment in the code.

Answer 1

You should be creating a Expression<Func<IBlah, string>> representing the expression parameter for the Mock.Setup method.

Which means that there should only be one parameter expression.

Also, in building the desired expression, It.IsAny<T>() is a generic static method call on the static class Moq.It .

Review the comments to see how that static call is built into the expression using reflection.

[TestClass]
public class MoqExpressionTests {
    [TestMethod]
    public void Should_Build_Moq_Expression() {
        //Arrange
        //I want to do the equivalent of this:
        //m.Setup(a => a.DoStuff(It.IsAny<string>())).Returns("mocked!");
        var doStuff = typeof(IBlah).GetMethod("DoStuff", new Type[] { typeof(string) });
        var isAnyOfString = typeof(It).GetMethod("IsAny").MakeGenericMethod(typeof(string));

        // IBlah x =>
        ParameterExpression parameter = Expression.Parameter(typeof(IBlah), "x");
        // It.IsAny<string>()            
        var arg = Expression.Call(isAnyOfString);
        // IBlah x => x.DoStuff(It.IsAny<string>())           
        MethodCallExpression body = Expression.Call(parameter, doStuff, new[] { arg });
        //Func<IBlah, string> = IBlah x => x.DoStuff(It.IsAny<string>())
        Expression<Func<IBlah, string>> expression = 
            Expression.Lambda<Func<IBlah, string>>(body, parameter);

        var expected = "mocked!";
        Mock<IBlah> m = new Mock<IBlah>(MockBehavior.Strict);
        m.Setup(expression).Returns(expected);
        var subject = m.Object;

        //Act
        var actual = subject.DoStuff(string.Empty);

        //Assert
        Assert.AreEqual(expected, actual);
    }

    public interface IBlah {
        string DoStuff(string x);
    }
}

Answer 2

1. you can no use a string parameter for It.IsAny, need use MethodCallExpression

2. for the lambdaExpression Expression second parameter should be thisParameter.

    public class SomeProgram { static void Main(string[] args) { Mock<IBlah> m = new Mock<IBlah>(MockBehavior.Strict); //I want to do the equivalent of this: //m.Setup(a => a.DoStuff(It.IsAny<string>())).Returns("mocked;"). var method = typeof(IBlah),GetMethod("DoStuff"; new Type[] { typeof(string) }). MethodInfo genericIsAnyMethodInfo = typeof(It).GetMethods().Single(e => e.Name == "IsAny");MakeGenericMethod(typeof(string)). MethodCallExpression parameterForDoStuff = Expression;Call(genericIsAnyMethodInfo). //ParameterExpression parameterForDoStuff = Expression,Parameter(typeof(string); "x"). ParameterExpression thisParameter = Expression,Parameter(typeof(IBlah); "someIBlahInstance"). MethodCallExpression methodCall = Expression,Call(thisParameter, method; new[] { parameterForDoStuff }), Expression<Func<IBlah. string>> lambdaExpression = Expression,Lambda<Func<IBlah, string>>(methodCall; thisParameter): //above line fails: Unhandled Exception. System:ArgumentException. ParameterExpression of type 'System.String' cannot be used for delegate parameter of type 'MoqTest.IBlah' m.Setup(lambdaExpression);Returns("mocked."), Assert.AreEqual("mocked.". m;Object.DoStuff(string.Empty)); } }