嘲笑委托“包装器”使用起订量

Question

本质上，我有一个用于“安全”调用委托的类。 “安全”本质上意味着如果某个成员已经被释放，则调用将被跳过。此类的代码：

    public class SafeOperationInvoker<TResponse> : IOperationInvoker<TResponse>
    where TResponse : class
    {
    private readonly IDisposableResource _callbackOwner;
    private readonly IOperationInvoker<TResponse> _next;

    public SafeOperationInvoker(IDisposableResource callbackOwner, IOperationInvoker<TResponse> next)
    {
        _callbackOwner = callbackOwner;
        _next = next;
    }

    public void Invoke(Action<TResponse> completedCallback)
    {
        //wrap the callback 
        _next.Invoke(response => SafeOperationCompleted(response, completedCallback));
    }

    private void SafeOperationCompleted(TResponse response, Action<TResponse> completedCallback)
    {
        //only invoke the callback if not disposed
        if (_callbackOwner != null && _callbackOwner.IsDisposed)
        {
            return;
        }
        completedCallback(response);
    }
}

我想要的是测试 SafeOperationCompleted 方法 - 如果回调Owner 已释放，则completedCallback 不会触发（反之亦然）。

我手工创建了一个假的，使我的测试功能正确：

private class FakeOperationInvoker : IOperationInvoker<string>
{
    public void Invoke(Action<string> completedCallback)
    {
        completedCallback("hi");
    }
}

测试：

[TestMethod]
public void SafeOperationCompleted_OriginalCallback_Invoked()
{
    int called = 0;

    var mockOwner = new Mock<IDisposableResource>();
    mockOwner.Setup(m => m.IsDisposed).Returns(false);
    var invoker = new SafeOperationInvoker<string>(mockOwner.Object, new FakeOperationInvoker());
    invoker.Invoke((o) => {  called++;});
    Assert.AreEqual(1, called, "Original callback should have been called");
}

我想做的是使用起订量创建一个模拟，其行为与 FakeOperationInvoker 的行为相同。我怎样才能实现这个目标？

Answer 1

你不能这样做吗：

var operationInvoker = new Mock<IOperationInvoker<string>>();
operationInvoker.Setup(oi => oi.Invoke(It.IsAny<Action<string>>())
                .Callback((Action<string>> callback) => callback("hi"));