gpt4 book ai didi

c# - ReactiveUI 测试中的调度程序

转载 作者:行者123 更新时间:2023-12-02 20:08:37 25 4
gpt4 key购买 nike

所以,当我为我的系统开发新功能时,我也尝试做 TDD - 遗憾的是,现在对于旧功能来说代码太大了。

但是,我发现有时在测试过程中会遇到困难 - 特别是在使用 DelayThrottle 时。

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

    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);
});
}
}


}

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

我现在知道,在玩弄时间的时候,我应该使用 TestScheduler。否则,请勿更改调度程序。

我现在知道,您不会在构造函数中执行任何异步操作,而是创建一个名为 Init 的命令,该命令在激活时执行此操作,并且您可以在测试中等待它(例如延迟基于构造函数参数创建集合,以便在 View 完整时实现流畅的 UI 动画)

但是,当我从上面运行这些测试时,我得到了:

Test results

有几件事我不明白。

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);
}

或者也许有一个我不知道的“刷新”方法?

此外,我学会了在 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);
});

但我仍然需要知道时间。

为什么一定要有Take(1)

最佳答案

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);
});
}

Why with Scheduler.Immediate the tests take twice the time?

如果你真的想深入研究并了解幕后发生的事情,我强烈推荐这个 Spy extension by James并添加时间戳。

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

Return 使用 ImmediateScheduler,您可能知道,单元测试运行程序中的 RxApp.MainThreadScheduler = ImmediateScheduler。因为这个scheduler is synchronous返回和延迟通知都必须相互等待。 Return 无法触发其 OnCompleted,直到 Delay 触发 OnNext,然后 Delay 的 OnCompleted 通知又延迟 2 秒。

关于c# - ReactiveUI 测试中的调度程序,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/54095419/

25 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com