1

方法 M 采用 2 个参数，P1 和 P2。P2 是代表。我想告诉一个模拟对象，“每当使用参数 P1 调用方法 M 时，调用 P2 并将对象 O 传递给它。” 我正在使用起订量。

以下方法有效，但似乎有点冗长。

this.DataCacheMock = Mock.Of<IDataCache>();
var dataObject = new DataObject();

Mock.Get(this.DataCacheMock)
.Setup(m => m.GetDataObject(123, It.IsAny<EventHandler<DataPortalResult<DataObject>>>()))
.Callback((int id, EventHandler<DataPortalResult<DataObject>> callback) => callback(null, new DataPortalResult(dataObject, null, null)));

我想将最后一点重构为通用辅助方法，以便我（和未来的测试作者）只需要编写如下内容：

TestTools.ArrangeDataPortalResult(this.DataCacheMock.GetDataObject, 123, dataObject);

最大的问题是：该辅助方法中会包含什么？到目前为止，我已经取得了部分成功，但我想知道是否有任何方法可以做到这一点。

第一次尝试（无效）

public static void ArrangeDataPortalResult<TMock, TResult, TParam>(
        TMock mockObject,
        Action<TMock, TParam, EventHandler<DataPortalResult<TResult>>> action,
        TParam parameter,
        TResult result)
    where TMock : class
{
    Moq.Mock.Get(mockObject)
        .Setup(m => action(m, parameter, Moq.It.IsAny<EventHandler<DataPortalResult<TResult>>>()))
        .Callback<TParam, EventHandler<DataPortalResult<TResult>>>((p, callback) =>
                callback(null, new DataPortalResult<TResult>(result, null, null)));
}

我可以这样调用这个方法：

TestTools.ArrangeDataPortalResult<IDataCache, DataObject, int>(
    this.DataCacheMock,
    (mock, param, handler) => mock.GetDataObject(param, handler),
    dataObjectId,
    dataObject);

事实证明，Moq 不喜欢我传递给 Setup 方法的内容。它抛出一个异常，说“表达式不是方法调用”。

第二次尝试

在这种方法中，我对 LINQ 表达式进行了一些操作（我以前从未做过）。

public static void ArrangeDataPortalResult<TMock, TParam, TResult>(
        TMock mockObject,
        Expression<Action<TMock>> methodCall, TResult result)
    where TMock : class
{
    // Get the method that will be called on the mock object, and the method's parameters.
    var methodCallExpression = methodCall.Body as MethodCallExpression;
    var parameters = methodCallExpression.Arguments;

    // Create a new parameter list, and substitute Moq.It.IsAny<EventHandler<DataPortalResult<TResult>>>() for the callback.
    // This is so that the test author doesn't need to write It.IsAny<blah>.
    var newParameters = parameters.Select(p => p).ToList();
    newParameters.RemoveAt(newParameters.Count - 1);
    var isAny = typeof(Moq.It).GetMethod("IsAny").MakeGenericMethod(typeof(EventHandler<DataPortalResult<TResult>>));
    var newCallbackParameterExpression = Expression.Call(null, isAny);
    newParameters.Add(newCallbackParameterExpression);

    // Create a new expression that contains the new IsAny parameter.
    var newMethodCallExpression = Expression.Call(methodCallExpression.Object, methodCallExpression.Method, newParameters);

    // Set up the mock object to expect a method call with the same parameters passed to it, but allow any callback to be passed to it.
    // Additionally, tell the mock object to immediately invoke its callback, and pass the given result to it.
    Moq.Mock.Get(mockObject)
        .Setup(Expression.Lambda<Action<TMock>>(newMethodCallExpression, methodCall.Parameters))
        .Callback<TParam, EventHandler<DataPortalResult<TResult>>>((p, callback) => callback(null, new DataPortalResult<TResult>(result, null, null)));
}

这个方法可以这样调用。

TestTools.ArrangeDataPortalResult<IDataCache, int, DataObject>(
    this.DataCacheMock,
    mock => mock.GetDataObject(123, null),
    dataObject);

这行得通，如果有必要，我可能会接受这样的事情。不幸的是，如果我不小心调用了错误的 DataCacheMock 方法（可能它有一个采用字符串而不是 int 的重载），那么我会得到一个运行时错误而不是编译时错误。

第三次尝试

public static void ArrangeDataPortalResultMoq<TMock, TParam, TResult>(
        Expression<Action> methodCall, TResult result)
    where TMock : class
{
    // Get the method that will be called on the mock object, and the method's parameters.
    // (This part is the same.)

    // Create a new parameter list, and substitute Moq.It.IsAny<EventHandler<DataPortalResult<TResult>>>() for the callback.
    // (This part is the same.)

    // Create a new expression that contains the new IsAny parameter.
    var newMethodCallExpression = Expression.Call(Expression.Parameter(typeof(TMock), "mock"), methodCallExpression.Method, newParameters);

    // Get the real mock object referred to in the method call.
    var mockObject = Expression.Lambda<Func<TMock>>(methodCallExpression.Object).Compile()();

    // Set up the mock object to expect a method call with the same parameters passed to it, but allow any callback to be passed to it.
    // Additionally, tell the mock object to immediately invoke its callback, and pass the given result to it.
    Moq.Mock.Get(mockObject)
        .Setup(Expression.Lambda<Action<TMock>>(newMethodCallExpression, Expression.Parameter(typeof(TMock), "mock")))
        .Callback<TParam, EventHandler<DataPortalResult<TResult>>>((p, callback) => callback(null, new DataPortalResult<TResult>(result, null, null)));
}

此版本从您传递给它的表达式中获取模拟对象，因此您在调用辅助方法时不必两次提及模拟对象：

TestTools.ArrangeDataPortalResultMoq<IDataCache, int, ceQryUomsBO>(
    () => this.DataCacheMock.GetDataObject(dataObjectId, null),
    dataObject);

但是，这种方法仍然存在与类型相同的问题。

我（和未来的测试作者）可能会处理顶部提到的冗长语法，我们可能会处理较低的类型安全性，因为测试会失败。不过，我仍然想看看最小起订量是否可行；我已经在兔子洞里走了这么远。:-)

4

1 回答 1

0

万一它对其他人有帮助，我最终得到了一个允许我这样做的解决方案：

TestTools.ArrangeDataPortalResult(
    this.DataCacheMock,
    (param1, callback) => this.DataCacheMock.Object.GetDataObject(param1, callback),
    123,
    dataObject);

这对我来说已经足够好了。我的解决方案如下。

public static void ArrangeDataPortalResult<TMocked, TResult, TParam>(Mock<TMocked> mock, Expression<Action<TParam, EventHandler<DataPortalResult<TResult>>>> expectedMethodCall, TParam parameter, TResult result)
    where TMocked : class
{
    var methodCallExpr = expectedMethodCall.Body as MethodCallExpression;
    var newMethodCallExpr = TransformAsyncCallForMoq<TMocked, TResult>(methodCallExpr, parameter);
    mock.Setup(newMethodCallExpr)
        .Callback<TParam, EventHandler<DataPortalResult<TResult>>>((p, callback) => callback(null, new DataPortalResult<TResult>(result, null, null)));
}

private static Expression<Action<TMocked>> TransformAsyncCallForMoq<TMocked, TResult>(MethodCallExpression methodCallExpr, params object[] expectedParameterValues)
{
    var methodCallParameters = methodCallExpr.Arguments;

    /// Transform a method call on a specific object,
    /// e.g. (param1, param2, callback) => MyMockObject.GetData(param1, param2, callback),
    /// into a lambda expression that Moq's Setup method can use, which looks more like this:
    /// m => m.GetData(5, "asdf", /* any event handler */).
    MethodCallExpression newMethodCallExpression = Expression.Call(
        Expression.Parameter(typeof(TMocked), "m"),
        methodCallExpr.Method,
        CreateParameterExpressionsWithAnyCallback(methodCallParameters, expectedParameterValues));

    return Expression.Lambda<Action<TMocked>>(newMethodCallExpression, Expression.Parameter(typeof(TMocked), "m"));
}


private static IEnumerable<Expression> CreateParameterExpressionsWithAnyCallback(IEnumerable<Expression> oldParameterExpressions, IEnumerable<object> expectedParameterValues)
{
    // Given a set of expressions and expected values, returns a new set of expressions that will 
    // allow Moq to set the proper method call expectation. Assumes there will be one more parameter
    // expression (the callback parameter) that has no expected value, and allows any value for it.

    var newParameterExpressions = oldParameterExpressions.Zip(expectedParameterValues,
        (paramExpr, paramVal) => Expression.Constant(paramVal, paramExpr.Type) as Expression);

    foreach (var expr in newParameterExpressions)
    {
        yield return expr;
    }

    var callbackParamExpr = oldParameterExpressions.Last();
    var isAny = typeof(Moq.It).GetMethod("IsAny").MakeGenericMethod(callbackParamExpr.Type);
    yield return Expression.Call(null, isAny) as Expression;
}

如果有人知道更简单的方法，我希望你能分享。:-)

于 2012-04-03T22:07:43.430 回答