How to test SelectMany() calling an async method?

[hymstra]

I'm trying to test a Viewmodel that calls an async method on my model(Foo). This is what I got:

using System.Reactive;
using Microsoft.Reactive.Testing;
using ReactiveUI.Testing;
using ReactiveUI.Fody.Helpers;
using ReactiveUI;
using System.Reactive.Linq;
using System.Reactive.Concurrency;

namespace Test;

public class Foo
{
    public int Value { get; private set; }

    public Foo() => Value = 42;

    public async Task<Unit> SetValueAsync(int value)
    {
        await RxApp.TaskpoolScheduler.Sleep(TimeSpan.FromMilliseconds(10));
        Value = value;
        return Unit.Default;
    }
}

public class ViewModel : ReactiveObject
{
    public ViewModel(Foo foo)
    {
        this.WhenAnyValue(x => x.Setpoint)
            //.Skip(1) // Skip the initial value
            .ObserveOn(RxApp.MainThreadScheduler)
            .SelectMany(foo.SetValueAsync)
            .Subscribe();
    }

    [Reactive]
    public int Setpoint { get; set; }
}

public class Test
{
    [Fact]
    public void ShouldCallAsyncMethodOnSettingReactiveSetpoint()
    {
        new TestScheduler().With(scheduler =>
        {
            //set
            var myFoo = new Foo();
            var myVm = new ViewModel(myFoo);

            //act
            scheduler.AdvanceBy(1); //process the initial value if not skipped
            scheduler.AdvanceByMs(20); //async processing

            myVm.Setpoint = 123;
            scheduler.AdvanceBy(2); //process reactive
            scheduler.AdvanceByMs(20); //I expect it to process setpoint setting

            //assert
            Assert.Equal(123, myFoo.Value);
        });
    }
}

I expected myFoo.Value to be 123. But foo.SetValueAsync is not called with 123. Only the initial call with value 0. If I use the skip(1) line the value is 42, which is logical seeing the previous result.

What do I do wrong?

[anaisbetts]

TestScheduler isn't compatible with async/await sadly - if you use TestScheduler, everything has to go through RxApp.MainThreadScheduler and RxApp.TaskPoolScheduler.

That being said, TestScheduler is more appropriate for testing elapsed time, but what you really care about here is ordering - "A" happened then "B", then "C" - we don't care about exactly how much time passes. The easiest way to do this is to start mocking methods that return Task<T> with AsyncSubject and IObservable<T>s with Subject:

public class ViewModel : ReactiveObject
{
    public ViewModel(Foo foo, Func<Foo, val, Task<Unit>> fooSetter = null)
    {
        // NB: There are lots of way better ways to replace methods to test them, this
        // is just for illustration purposes
        fooSetter = fooSetter ?? ((x, val) => x.SetValueAsync(val));

        this.WhenAnyValue(x => x.Setpoint)
            //.Skip(1) // Skip the initial value
           // .ObserveOn(RxApp.MainThreadScheduler)  // NB: WhenAny is guaranteed to already be on UI thread!
            .SelectMany(v => fooSetter(foo, v))
            .Subscribe();
    }

    [Reactive]
    public int Setpoint { get; set; }
}

public class Test
{
    [Fact]
    public void ShouldCallAsyncMethodOnSettingReactiveSetpoint()
    {
          //set it up
          var myFoo = new Foo();
          var completion = new AsyncSubject<Unit>();

          var myVm = new ViewModel(myFoo, (foo, x) => {
            await completion;
            foo.Value = x;
          }));
      
          // Set but we didn't complete it yet!
          myVm.Setpoint = 123;
          Assert.NotEqual(123, myFoo.Value);
 
          completion.OnNext(Unit.Default);
          completion.OnCompleted();

          // Now we did it!
          Assert.Equal(123, myFoo.Value);
        });
    }
}

[hymstra]

Thanks. The use of a scheduler actually arose from originally trying to test this behaviour when .Throttle() was involved in the this.WhenAnyValue call. Is there a solution for such a test?

[anaisbetts]

If you want to test if Throttle is actually throttling (and I would argue that tbh, you should just Trust that Throttle works!), then that's when you need TestScheduler and you need to give up Task anywhere in that code path

[hymstra]

I agree that I'm not really interested in whether Throttle works, I'm trusting it does. It is just part of the actual code I'm trying to test. I didn't want to wait realtime for throttle to complete in my tests so I looked into schedulers. Seeing what you originally mentioned that everything should flow through the RxApp schedulers, or I should omit Task in the WhenAny code path, it seems I have to modify my code to be testable.

Am I correct in saying that an async method called by this.WhenAnyValue.SelectMany() is not guaranteed to run on the same scheduler as the caller? (i.e. the RxApp.MainThreadScheduler)

Thanks for your help and quick responses.

[anaisbetts]

or I should omit Task in the WhenAny code path, it seems I have to modify my code to be testable.

When it comes to code testability, the use of Task can still be accommodated through the Subject trick. This means that you can continue to utilize async/await for the majority of your code. However, if there are specific portions that you need to test using TestScheduler / time-travel, you have to avoid Task

Am I correct in saying that an async method called by this.WhenAnyValue.SelectMany() is not guaranteed to run on the same scheduler as the caller? (i.e. the RxApp.MainThreadScheduler)

Correct, the results of the SelectMany can come back on any thread. The rule is, Rx.NET generally Doesn't Care what thread code runs on - when you do something that inherently is concurrent, results simply stay on whatever thread they come back on. Sometimes you as the developer care, so that's where ObserveOn helps you to move results from one thread to another