25

我想对一个调用另一个服务方法的方法进行单元测试，该方法返回一个IAsyncEnumerable<T>. 我已经为我的服务创建了一个模拟，Mock<MyService>我想设置这个模拟，但我不知道该怎么做。可能吗 ？是否有其他方法可以对调用重新调整的方法的方法进行单元测试IAsyncEnumerable 

public async Task<List<String>> MyMethodIWantToTest()
{
  var results = new List<string>();
  await foreach(var item in _myService.CallSomethingReturningAsyncStream())
  {
    results.Add(item);
  }
  return results;
}
4

4 回答 4

37

正如 Jeroen 建议的那样，我建议使用ToAsyncEnumerablefrom 。System.Linq.Async看起来你正在使用 Moq，所以这看起来像：

async Task MyTest()
{
  var mock = new Mock<MyService>();
  var mockData = new[] { "first", "second" };
  mock.Setup(x => x.CallSomethingReturningAsyncStream()).Returns(mockData.ToAsyncEnumerable());

  var sut = new SystemUnderTest(mock.Object);
  var result = await sut.MyMethodIWantToTest();

  // TODO: verify `result`
}
于 2019-11-27T14:19:33.420 回答
35

如果您不想做任何特别的事情，例如延迟返回，这通常是异步枚举的点，那么您可以创建一个为您返回值的生成器函数。

public static async IAsyncEnumerable<string> GetTestValues()
{
    yield return "foo";
    yield return "bar";

    await Task.CompletedTask; // to make the compiler warning go away
}

有了它，您可以简单地为您的服务创建一个模拟并测试您的对象：

var serviceMock = new Mock<IMyService>();
serviceMock.Setup(s => s.CallSomethingReturningAsyncStream()).Returns(GetTestValues);

var thing = new Thing(serviceMock.Object);
var result = await thing.MyMethodIWantToTest();
Assert.Equal("foo", result[0]);
Assert.Equal("bar", result[1]);

当然，既然你现在使用的是生成器函数，你也可以让它变得更复杂并添加实际的延迟，甚至包括一些机制来控制屈服。

于 2019-11-27T14:23:23.083 回答
2

这实际上取决于您使用的模拟框架。但是，它会像这个例子一样简单，使用Moq

var data = new [] {1,2,3,4};
var mockSvc = new Mock<MyService>();
mockSvc.Setup(obj => obj.CallSomethingReturningAsyncStream()).Returns(data.ToAsyncEnumerable());
于 2019-11-27T14:11:46.257 回答
2

解决此问题的一种方法是使用包装IEnumerable同步枚举的专用测试类。

TestAsyncEnumerable.cs

internal class TestAsyncEnumerable<T> : List<T>, IAsyncEnumerable<T>
{
   public TestAsyncEnumerable(IEnumerable<T> enumerable) : base(enumerable) { }

   public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default) => new TestAsyncEnumerator<T>(GetEnumerator());
}

internal class TestAsyncEnumerator<T> : IAsyncEnumerator<T>
{
   private readonly IEnumerator<T> _inner;

   public TestAsyncEnumerator(IEnumerator<T> inner)
   {
      _inner = inner;
   }

   public ValueTask<bool> MoveNextAsync() => new ValueTask<bool>(_inner.MoveNext());

   public T Current => _inner.Current;

   public ValueTask DisposeAsync()
   {
      _inner.Dispose();

      return new ValueTask(Task.CompletedTask);
   }
}

用法：

[Fact]
public async Task MyTest() {
   var myItemRepository = A.Fake<IMyItemRepository>();

   A.CallTo(       () => myRepository.GetAll())
    .ReturnsLazily(() => new TestAsyncEnumerable<MyItem>(new List<MyItem> { new MyItem(), ... }));


   //////////////////
   /// ACT & ASSERT
   ////////
}
于 2020-01-04T12:48:14.470 回答