C# 单元测试 - 证明 Task.WhenAll() 中的异步方法正确异步运行

Question

我有一个我想测试的方法，它有四个异步运行的方法。我想要一个单元测试来证明它们是并行运行的。我不知道该怎么做，也无法在网上找到任何东西。

这是我所拥有的一个例子

我正在尝试测试的方法

public async Task<IEnumerable<ReturnData>> GetData()
{
    List<ReturnData> returnData = new List<ReturnData>();

    Task<IEnumerable<ReturnData>> dataTypeA = dataServiceA.GetDataTypeA();
    Task<IEnumerable<ReturnData>> dataTypeB = dataServiceB.GetDataTypeB();
    Task<IEnumerable<ReturnData>> dataTypeC = dataServiceC.GetDataTypeC();
    Task<IEnumerable<ReturnData>> dataTypeD = dataServiceD.GetDataTypeD();

    await Task.WhenAll(dataTypeA, dataTypeB, dataTypeC, dataTypeD);

    returnData.AddRange(dataTypeA.Result);
    returnData.AddRange(dataTypeB.Result);
    returnData.AddRange(dataTypeC.Result);
    returnData.AddRange(dataTypeD.Result);

    return returnData;
}

我的单元测试

[TestMethod]
public async Task GetDataTestAsync()
{

    mockedDataServiceA.Setup(a => a.GetDataTypeA())
        .Callback(() => Thread.Sleep(1000))
        .ReturnsAsync(mockedDataA);

    mockedDataServiceB.Setup(a => a.GetDataTypeB())
        .Callback(() => Thread.Sleep(1000))
        .ReturnsAsync(mockedDataB);

    mockedDataServiceC.Setup(a => a.GetDataTypeC())
        .Callback(() => Thread.Sleep(1000))
        .ReturnsAsync(mockedDataC);

    mockedDataServiceD.Setup(a => a.GetDataTypeD())
        .Callback(() => Thread.Sleep(1000))
        .ReturnsAsync(mockedDataD);

    IDataService dataService = new DataService(mockedDataServiceA.Object,
                                            mockedDataServiceB.Object,
                                            mockedDataServiceC.Object,
                                            mockedDataServiceD.Object,);

    DateTime startTime = DateTime.Now;
    IEnumerable<ReturnData> data = await dataService.GetData();
    DateTime endTime = DateTime.Now;

    TimeSpan timeDiff = endTime.Subtract(startTime);

    Assert.IsTrue(timeDiff.TotalSeconds < 4);
}

我尝试过同时使用Thread.Sleep(1000) 和Task.Delay(1000)

两者都没有给出想要的结果。我希望测试只运行 1 秒多一点，因为每个方法都应该并行运行。

当使用Thread.Sleep(1000) 时，测试会运行 4.1 秒（测试失败）

使用Task.Delay(1000) 时，测试运行时间少于 100 毫秒。这在技术上可以通过我拥有的断言测试，但不是预期的结果。

我知道当我运行我的 Web 服务时，这些方法确实是并行运行的，我只是想要一个单元测试来证明该功能，并在将来有任何代码更改时保护该功能。

Answer 1

使用 TaskCompletionSource 控制任务何时完成。

请注意，此测试假定 GetDataAsync 调用返回该方法等待的第一个任务。如果测试等待其他任务，那么您需要确保在调用所有 GetDataAsync 方法之前不调用 mock.Verify()，可能通过在模拟回调中减少 CountdownEvent。

public class UnitTest1
{
    [Fact]
    public async Task Test1()
    {
        // TCS allows the test to control when the tasks complete
        // without needing to use Sleep or Delay (which will make the
        // test take unnecessarily long and probably introduces a race
        // condition)
        var (mockA, tcsA) = CreateMock();
        var (mockB, tcsB) = CreateMock();
        var (mockC, tcsC) = CreateMock();

        var service = new DataService(mockA.Object, mockB.Object, mockC.Object);

        var task = service.GetAllDataAsync();

        // Verify the method hasn't finished yet (AKA it's awaiting the tasks)
        Assert.NotEqual(TaskStatus.RanToCompletion, task.Status);

        // Verify that all the methods have been called
        mockA.Verify(m => m.GetDataAsync());
        mockB.Verify(m => m.GetDataAsync());
        mockC.Verify(m => m.GetDataAsync());

        // Now complete all the tasks and verify the method completes
        tcsA.SetResult(null);
        tcsB.SetResult(null);
        tcsC.SetResult(null);
        await task;
    }

    (Mock<IGetData>, TaskCompletionSource<object>) CreateMock()
    {
        var tcs = new TaskCompletionSource<object>();
        var mock = new Mock<IGetData>();
        mock.Setup(m => m.GetDataAsync()).Returns(tcs.Task);
        return (mock, tcs);
    }
}

public interface IGetData
{
    Task<object> GetDataAsync();
}

class DataService
{
    private IGetData _serviceA;
    private IGetData _serviceB;
    private IGetData _serviceC;
    public DataService(IGetData serviceA, IGetData serviceB, IGetData serviceC)
    {
        _serviceA = serviceA;
        _serviceB = serviceB;
        _serviceC = serviceC;
    }

    public async Task GetAllDataAsync()
    {
        var taskA = _serviceA.GetDataAsync();
        var taskB = _serviceB.GetDataAsync();
        var taskC = _serviceC.GetDataAsync();

        await Task.WhenAll(taskA, taskB, taskC);

        // do something with results;
    }
}