模拟 Task.Delay

Question

我有一个带有以下代码行的方法：await Task.Delay(waitTime).ConfigureAwait(false);

在单元测试中，是否有一种好的策略可以避免实际等待几秒钟，而是验证我们尝试等待特定的秒数。

例如，是否有一种方法可以向我的方法注入另一个参数，就像在这个（虚构的）示例中，我注入了一个名为ITaskWaiter接口的模拟对象：

// Arrange
var mockWait = new Mock<ITaskWaiter>(MockBehavior.Strict);
mockWait.Setup(w => w.Delay(It.Is<TimeSpan>(t => t.TotalSeconds == 2)));

// Act
myObject.MyMethod(mockWait.Object);

// Assert
mockWait.Verify();

- desautelsj

Answer 1

您可以像这样定义一个“延迟器”接口：

public interface IAsyncDelayer
{
    Task Delay(TimeSpan timeSpan);
}

然后你可以为生产代码提供以下实现：

public class AsyncDelayer : IAsyncDelayer
{
    public Task Delay(TimeSpan timeSpan)
    {
        return Task.Delay(timeSpan);
    }
}

现在，您的类看起来可能是这样的：

public class ClassUnderTest
{
    private readonly IAsyncDelayer asyncDelayer;

    public ClassUnderTest(IAsyncDelayer asyncDelayer)
    {
        this.asyncDelayer = asyncDelayer;
    }

    public async Task<int> MethodUnderTest()
    {
        await asyncDelayer.Delay(TimeSpan.FromSeconds(2));

        return 5;
    }
}

这是依赖注入的基本应用。基本上，我们将异步等待的逻辑提取到另一个类中，并为其创建了一个接口，以实现多态性。

在生产环境中，您可以像这样组合您的对象：

var myClass = new ClassUnderTest(new AsyncDelayer());

现在，在您的测试中，您可以创建一个立即返回的假延迟器，就像这样：

[TestMethod]
public async Task TestMethod1()
{
    var mockWait = new Mock<IAsyncDelayer>();

    mockWait.Setup(m => m.Delay(It.IsAny<TimeSpan>())).Returns(Task.FromResult(0));

    var sut = new ClassUnderTest(mockWait.Object);

    var result = await sut.MethodUnderTest();

    Assert.AreEqual(5, result);
}

- Yacoub Massad

Answer 2

被接受的答案是正确的方法。

备选方案1

如果您想要“隐藏”客户端代码（在不同的程序集中）的依赖关系，但允许测试使用它：

public class ClassUnderTest
{
    private readonly IAsyncDelayer asyncDelayer;

    public ClassUnderTest() : this(new AsyncDelayer()) { }   // used by client code

    internal ClassUnderTest(IAsyncDelayer asyncDelayer)      // used by tests
    {
        this.asyncDelayer = asyncDelayer;
    }

    public async Task<int> MethodUnderTest()
    {
        await asyncDelayer.Delay(TimeSpan.FromSeconds(2));
        return 5;
    }
}

备选方案2

如果您不想引入可模拟的依赖项（无论出于什么原因），那么可以将延迟提取为虚拟方法并进行模拟：

public class ClassUnderTest
{
    internal virtual Task Delay(TimeSpan delay) => Task.Delay(delay);

    public async Task<int> MethodUnderTest()
    {
        await Delay(TimeSpan.FromSeconds(2));
        return 5;
    }
}

在测试中，您需要部分模拟该类。然后，将Delay()模拟为返回Task.CompletedTask以便它不执行任何操作。您还可以验证已使用值2调用模拟方法。

- lonix