Question

我在测试使用Observable.FromAsync<T>()和Observable.Switch<T>()的课程时遇到了麻烦。它的作用是等待一个触发器observable产生一个值，然后它启动一个异步操作，最后重新收集所有操作＆＃39;产生单个输出序列。它的要点是：

var outputStream = triggerStream
  .Select(_ => Observable
    .FromAsync(token => taskProducer.DoSomethingAsync(token)))
  .Switch();

我用最少的部分进行了一些健全性检查测试，以了解发生了什么，这里的测试结果是评论：

class test_with_rx : nspec
{
  void Given_async_task_and_switch()
  {
    Subject<Unit> triggerStream = null;
    TaskCompletionSource<long> taskDriver = null;
    ITestableObserver<long> testObserver = null;
    IDisposable subscription = null;

    before = () =>
    {
      TestScheduler scheduler = new TestScheduler();
      testObserver = scheduler.CreateObserver<long>();
      triggerStream = new Subject<Unit>();
      taskDriver = new TaskCompletionSource<long>();

      // build stream under test
      IObservable<long> streamUnderTest = triggerStream
        .Select(_ => Observable
          .FromAsync(token => taskDriver.Task))
        .Switch();

      /* Also tried with this Switch() overload
      IObservable<long> streamUnderTest = triggerStream
          .Select(_ => taskDriver.Task)
          .Switch(); */

      subscription = streamUnderTest.Subscribe(testObserver);
    };

    context["Before trigger"] = () =>
    {
      it["Should not notify"] = () => testObserver.Messages.Count.Should().Be(0);
      // PASSED
    };

    context["After trigger"] = () =>
    {
      before = () => triggerStream.OnNext(Unit.Default);

      context["When task completes"] = () =>
      {
        long result = -1;

        before = () =>
        {
          taskDriver.SetResult(result);
          //taskDriver.Task.Wait();  // tried with this too
        };

        it["Should notify once"] = () => testObserver.Messages.Count.Should().Be(1);
        // FAILED: expected 1, actual 0

        it["Should notify task result"] = () => testObserver.Messages[0].Value.Value.Should().Be(result);
        // FAILED: of course, index out of bound
      };
    };

    after = () =>
    {
      taskDriver.TrySetCanceled();
      taskDriver.Task.Dispose();
      subscription.Dispose();
    };
  }
}

在其他测试中我也完成了mocks，我可以看到传递给FromAsync的Func实际上是被调用的（例如taskProducer.DoSomethingAsync(token)），但是接下来看起来就没有了，输出流没有产生价值。

我还尝试在达到预期之前插入一些Task.Delay(x).Wait()或一些taskDriver.Task.Wait()，但没有运气。

我看了this SO thread并且我知道调度程序，但是初看起来我以为我不需要它们，没有使用ObserveOn()。我错了吗？我错过了什么？ TA

为了完整性，测试框架是NSpec，断言库是FluentAssertions。

Answer 1

您所遇到的是一起测试Rx和TPL的情况。可以找到详尽的解释here，但我会尝试为您的特定代码提供建议。

基本上你的代码工作正常，但你的测试不是。 Observable.FromAsync将在提供的任务上转换为ContinueWith，该任务将在任务池上执行，因此是异步的。

修复测试的多种方法:(从丑陋到复杂）

结果集后休息（注意等待不起作用，因为等待不等待继续）
```
taskDriver.SetResult(result);
Thread.Sleep(50);
```
在执行FromAsync之前设置结果（因为如果任务完成，FromAsync将返回立即IObservable，也将跳过ContinueWith）
```
taskDriver.SetResult(result);
triggerStream.OnNext(Unit.Default);
```

用可测试的替代方法替换FromAsync，例如

public static IObservable<T> ToObservable<T>(Task<T> task, TaskScheduler scheduler)
{
    if (task.IsCompleted)
    {
        return task.ToObservable();
    }
    else
    {
        AsyncSubject<T> asyncSubject = new AsyncSubject<T>();
        task.ContinueWith(t => task.ToObservable().Subscribe(asyncSubject), scheduler);
        return asyncSubject.AsObservable<T>();
    }
}

（使用synchronous TaskScheduler或testable个

使用Observable.FromAsync和Observable.Switch进行单元测试失败

1 个答案: