那些遇到过的问题

ReactiveUI 测试中的调度程序

Krz*_*nek 2 c# unit-testing system.reactive reactiveui

因此，当我为我的系统开发新功能时，我也尝试进行 TDD - 遗憾的是，现在为旧功能执行此操作的代码太大了。

然而，我发现有时我在测试过程中会碰壁——尤其是在使用Delay和时Throttle。

我读了很多书，我想我比一周前知道了更多，但我想把所有这些付诸实践。我写了一些实验：

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Reactive;
    using System.Reactive.Concurrency;
    using System.Reactive.Linq;
    using System.Reactive.Threading.Tasks;
    using System.Text;
    using System.Threading.Tasks;
    using Microsoft.Reactive.Testing;
    using NUnit.Framework;
    using NUnit.Framework.Internal.Commands;
    using ReactiveUI;
    using ReactiveUI.Testing;

    namespace UtilsTests
    {
        [TestFixture]
        public class SchedulersTests
        {
            private int SecondsN = 1;

            [Test]
            public async Task NoScheduler()
            {
                var t = Observable.Return(Unit.Default).Delay(TimeSpan.FromSeconds(SecondsN), RxApp.MainThreadScheduler)
                    .ObserveOn(RxApp.MainThreadScheduler)
                    .ToTask();
                await t;
            }

            [Test]
            public Task ImmediateSchedulerExperiment()
            {
                return Scheduler.Immediate.With(async s =>
                {
                    var t = Observable.Return(Unit.Default).Delay(TimeSpan.FromSeconds(SecondsN), RxApp.MainThreadScheduler).ToTask();
                    await t;
                });
            }

            [Test]
            public Task ImmediateSchedulerExperiment2()
            {
                return Scheduler.Immediate.With(async s =>
                {
                    var t = Observable.Return(Unit.Default).Delay(TimeSpan.FromSeconds(SecondsN), s).FirstAsync().ToTask();
                    await t;
                });
            }

            [Test]
            public void ImmediateSchedulerExperiment3()
            {
                Scheduler.Immediate.With(s =>
                {
                    var t = false;
                    Observable.Return(Unit.Default).Delay(TimeSpan.FromSeconds(SecondsN), s)
                        .Subscribe(_ =>
                        {
                            t = true;
                        });

                    Assert.IsTrue(t);
                });
            }


            [Test]
            public void TestSchedulerExperiment_SchedulersNotSpecified()
            {
                new TestScheduler().With(s =>
                {
                    var t = false;
                    Observable.Return(Unit.Default).Delay(TimeSpan.FromSeconds(SecondsN), s)
                        .Subscribe(_ =>
                        {
                            t = true;
                        });

                    s.AdvanceByMs(SecondsN * 1000);

                    Assert.IsTrue(t);
                });
            }

            [Test]
            public void TestSchedulerExperiment_DeylaOn_RxMainThread()
            {
                new TestScheduler().With(s =>
                {
                    var t = false;
                    Observable.Return(Unit.Default).Delay(TimeSpan.FromSeconds(SecondsN), RxApp.MainThreadScheduler)
                        .Subscribe(_ =>
                        {
                            t = true;
                        });

                    s.AdvanceByMs(SecondsN * 1000);

                    Assert.IsTrue(t);
                });
            }

            [Test]
            public void TestSchedulerExperiment_DeylaOn_RxTaskPool()
            {
                new TestScheduler().With(s =>
                {
                    var t = false;
                    Observable.Return(Unit.Default).Delay(TimeSpan.FromSeconds(SecondsN), RxApp.TaskpoolScheduler)
                        .Subscribe(_ =>
                        {
                            t = true;
                        });

                    s.AdvanceByMs(SecondsN * 1000);

                    Assert.IsTrue(t);
                });
            }

            [Test]
            public void TestSchedulerExperiment_RunOnTaskPool_ObserveOnMainThread()
            {
                new TestScheduler().With(s =>
                {
                    var t = false;
                    Observable.Return(Unit.Default)
                        .Delay(TimeSpan.FromSeconds(SecondsN), RxApp.TaskpoolScheduler)
                        .ObserveOn(RxApp.MainThreadScheduler)
                        .Subscribe(_ =>
                        {
                            t = true;
                        });

                    s.AdvanceByMs(SecondsN * 1000);

                    Assert.IsTrue(t);
                });
            }

            [Test]
            public void TestSchedulerExperiment_RunOnTaskPool_ObserveOnTaskpool()
            {
                new TestScheduler().With(s =>
                {
                    var t = false;
                    Observable.Return(Unit.Default)
                        .Delay(TimeSpan.FromSeconds(SecondsN), RxApp.TaskpoolScheduler)
                        .ObserveOn(RxApp.TaskpoolScheduler)
                        .Subscribe(_ =>
                        {
                            t = true;
                        });

                    s.AdvanceByMs(SecondsN * 1000);
                    s.AdvanceByMs(1);

                    Assert.IsTrue(t);
                });
            }

            [Test]
            public void TestSchedulerExperiment_RunOnTaskPool_ObserveOnMainThread_MainThreadIsAnotherInstance()
            {
                new TestScheduler().With(s =>
                {
                    var mainThreadScheduler = new TestScheduler();
                    RxApp.MainThreadScheduler = mainThreadScheduler;
                    var t = false;
                    Observable.Return(Unit.Default)
                        .Delay(TimeSpan.FromSeconds(SecondsN), RxApp.TaskpoolScheduler)
                        .ObserveOn(RxApp.MainThreadScheduler)
                        .Subscribe(_ =>
                        {
                            t = true;
                        });

                    s.AdvanceByMs(SecondsN * 1000);
                    mainThreadScheduler.AdvanceBy(1);
                    Assert.IsTrue(t);
                });
            }

            [Test]
            public void TestSchedulerExperiment_RunOnTest_ObserveOnTest()
            {
                new TestScheduler().With(s =>
                {
                    var t = false;
                    var obs = Observable.Return(Unit.Default)
                        .Delay(TimeSpan.FromSeconds(SecondsN), s)
                        .ObserveOn(s);
                    obs
                        .Subscribe(_ =>
                        {
                            t = true;
                        });

    //                s.AdvanceByMs(SecondsN * 1000);
    //                s.AdvanceBy(1);

                    s.AdvanceUntil(obs);

                    Assert.IsTrue(t);
                });
            }
        }


    }
Run Code Online (Sandbox Code Playgroud)

起初，我认为这样Scheduler.Immediate可以解决问题，在延迟后立即执行事情，天哪，这是错误的。我发现这篇文章，它解释得相当好。我还发现了这篇文章，解释了哪个运算符使用哪个调度程序。

我现在知道，当玩弄时间时，我应该使用 TestScheduler。否则，不要更改调度程序。

我现在知道，您不会在构造函数中执行任何异步操作，而是创建一个名为的命令，假设Init它在激活时执行此操作，并且您可以在测试中等待它（例如，基于构造函数参数延迟集合创建，以允许平滑的 UI 动画当视图完成时）

但是，当我从上面运行这些测试时，我得到：

检测结果

有几件事我不明白。

1）为什么Scheduler.Immediate测试需要两倍的时间？我想我明白为什么Take(1)没有什么区别，但仍然......

2）使用TestSchduler时，如何确定前进多少？

我注意到在测试中TestSchedulerExperiment_RunOnTest_ObserveOnTest我必须做额外的事情AdvanceBy(1)，因为它也是观察者。所以，当链条更长、观察者更多时，就很难统计它们了。

这是常见的做法吗scheduler.AdvanceBy(10000000000000);？

我尝试创建AdvanceUntil扩展，但我知道它由于多种原因而很糟糕（例如冷可观察量）。

 public static void AdvanceUntil<TIgnore>(this TestScheduler s, IObservable<TIgnore> obs, double? advanceByMs = null)
        {
            var done = false;
            obs.Subscribe(_ => done = true, (ex) => done = true, () => done = true);

            while(!done)
                s.AdvanceByMs(advanceByMs ?? 100);
        }
Run Code Online (Sandbox Code Playgroud)

或者也许有一种我不知道的“冲洗”方法？

另外，我学会了等待里面的东西TestScheduler.With：

    [Test]
    public Task TestSchedulerExperiment_await()
    {
        return new TestScheduler().With(async s =>
        {
            var v = false;

            var t = Observable.Return(true).Delay(TimeSpan.FromSeconds(SecondsN), s)
                .Take(1) // without hits the test never ends
                .ToTask();
            s.AdvanceByMs(SecondsN * 1000);
            v = await t;

            Assert.IsTrue(v);
        });
Run Code Online (Sandbox Code Playgroud)

但我仍然需要知道时间。

为什么一定要有Take(1)？

Col*_*man 5

Scheduler.Start()执行已安排的所有内容，因此您不需要该扩展方法。

我建议大多数时候不要将 async/await 与 Rx 混合，特别是对于基于时间的功能，由于 Delay 运算符，这基本上是您的所有测试。否则，您可能需要等待几分钟才能完成单个测试。因此 async/await 在其中任何一个中都没有任何作用。

例如，在像TestSchedulerExperiment wait测试这样的场景中，您只需要测试调度程序和订阅即可。该测试将简单地变成：

// Passing test    
[Test]
public void TestSchedulerExperiment()
{
    new TestScheduler().With(s =>
    {
        var v = false;

        Observable
            .Return(true)
            .Delay(TimeSpan.FromSeconds(1), s)
            .Subscribe(_ => v = true);

        s.Start();
        Console.WriteLine("Scheduler clock value: {0}", s.Clock);

        Assert.True(v);
    });
}
Run Code Online (Sandbox Code Playgroud)

为什么使用 Scheduler.Immediate 测试需要两倍的时间？

如果您真的想深入研究并了解幕后发生的情况，我强烈推荐James 的这个 Spy 扩展并添加时间戳。

var t = Observable
    .Return(Unit.Default).Spy("Return")
    .Delay(TimeSpan.FromSeconds(2), RxApp.MainThreadScheduler).Spy("Delay")
    .ToTask();
await t;

// Partial output
Return: OnNext(()) on Thread: 1, 23:22:41.2631845
Delay: OnNext(()) on Thread: 1, 23:22:43.2891836
Return: OnCompleted() on Thread: 1, 23:22:43.2921808
Delay: OnCompleted() on Thread: 1, 23:22:45.2958130
Run Code Online (Sandbox Code Playgroud)

Return使用 ImmediateScheduler，您可能知道，单元测试运行程序中的 RxApp.MainThreadScheduler = ImmediateScheduler。因为这个调度程序是同步的，所以 Return 和 Delay 通知都必须互相等待。Return 无法触发其 OnCompleted，直到 Delay 触发 OnNext，然后 Delay 的 OnCompleted 通知又延迟 2 秒。

归档时间：

查看次数：

950 次

最近记录：

7 年 前
每个可观察运营商的默认调度程序是什么？ 39
如何查看我的响应式扩展查询的作用？ 17
更多相关链接
相关归档
C#的隐藏功能？ 1475
.NET配置(app.config/web.config/settings.settings) 161
单元测试期间调试断言的最佳实践 46
WPF CreateBitmapSourceFromHBitmap()内存泄漏 46
更改文本框高度？ 46
如何为类中的所有测试设置测试类别 43
痛苦地减慢Azure表插入和删除批处理操作 38
使用基于日期/时间的对象进行Django单元测试 26
存储库本身通常不会被测试？ 11
如何用很少的单位对代码进行单元测试 9
难疑归档
堆栈和堆的内容和位置是什么？ 7847
为什么减去这两次(在1927年)给出一个奇怪的结果？ 6628
使用jQuery从下拉列表(选择框)中获取所选文本 2240
O(log n)究竟意味着什么？ 2021
什么是Android上的"上下文"？ 1872
当用户将鼠标悬停在列表项上时,将光标置为手 1871
接口和抽象类之间有什么区别？ 1705
使当前的Git分支成为主分支 1555
对JavaScript对象数组进行排序 1233
什么是首选的Bash shebang？ 1051