单元测试时模拟CancellationToken.IsCancellationRequested

Question

我想测试一个应该持续运行直到被杀死的任务。 假设正在测试以下方法：

public class Worker
{
  public async Task Run(CancellationToken cancellationToken)
  {
    while (!cancellationToken.IsCancellationRequested)
    {
      try
      {
        // do something like claim a resource
      }
      catch (Exception e)
      {
        // catch exceptions and print to the log
      }
      finally
      {
        // release the resource
      }
    }
  }
}

和一个测试用例

[TestCase]
public async System.Threading.Tasks.Task Run_ShallAlwaysReleaseResources()
{
  // Act
  await domainStateSerializationWorker.Run(new CancellationToken());  

  // Assert
  // assert that resource release has been called
}

问题是任务永远不会终止，因为从未请求取消。 最终我想创建一个像MockRepository.GenerateStub<CancellationToken>()这样的CancellationToken存根，并告诉它在对IsCancellationRequested的哪个调用上返回true ，但是CancellationToken不是引用类型，所以这是不可能的。

所以问题是如何在Run执行n次迭代然后终止的情况下进行测试？ 不重构Run有可能吗？

Answer 1

这取决于Run 。 如果有一些注入的依赖

例如

public interface IDependency {
    Task DoSomething();
}

public class Worker {
    private readonly IDependency dependency;

    public Worker(IDependency dependency) {
        this.dependency = dependency;
    }

    public async Task Run(CancellationToken cancellationToken) {
        while (!cancellationToken.IsCancellationRequested) {
            try {
                // do something like claim a resource
                await dependency.DoSomething();
            } catch (Exception e) {
                // catch exceptions and print to the log
            } finally {
                // release the resource
            }
        }
    }
}

然后可以模拟和监视它以计算某个成员被调用的次数。

[TestClass]
public class WorkerTests {
    [TestMethod]
    public async Task Sohuld_Cancel_Run() {
        //Arrange
        int expectedCount = 5;
        int count = 0;
        CancellationTokenSource cts = new CancellationTokenSource();
        var mock = new Mock<IDependency>();
        mock.Setup(_ => _.DoSomething())
            .Callback(() => {
                count++;
                if (count == expectedCount)
                    cts.Cancel();
            })
            .Returns(() => Task.FromResult<object>(null));

        var worker = new Worker(mock.Object);

        //Act
        await worker.Run(cts.Token);

        //Assert
        mock.Verify(_ => _.DoSomething(), Times.Exactly(expectedCount));
    }
}

Answer 2

在不更改代码的情况下，您可以做的最好的事情是在特定时间后取消。 CancellationTokenSource.CancelAfter()方法使这变得简单：

[TestCase]
public async System.Threading.Tasks.Task Run_ShallAlwaysReleaseResources()
{

  // Signal cancellation after 5 seconds
  var cts = new TestCancellationTokenSource();
  cts.CancelAfter(TimeSpan.FromSeconds(5));

  // Act
  await domainStateSerializationWorker.Run(cts.Token);  

  // Assert
  // assert that resource release has been called
}

你编写代码的方式（检查IsCancellationRequested每次迭代只有一次），表示取消将在一些数量完全迭代的发生。 它只是不会每次都是相同的数字。

如果您想在特定次数的迭代后取消，那么您唯一的选择是修改您的代码以跟踪发生了多少次迭代。

我以为我可以创建一个继承自CancellationTokenSource的新类来跟踪IsCancellationRequested已被测试的次数，但这是不可能的。

Answer 3

您也可以执行 CancellationToken.None。 由于这是一个测试，您不需要取消任何异步方法。

[TestCase]
public async System.Threading.Tasks.Task Run_ShallAlwaysReleaseResources()
{
  // Act
  await domainStateSerializationWorker.Run(CancellationToken.None);  

  // Assert
  // assert that resource release has been called
}