ReactiveUI - Cancel a command from another - Unit Test of code from documentation fails

Question

I take the code from ReactiveUi website documentation and try to unit test it but it fails.
It is about invoking a command to cancel another one.

Below is the class to test.

public class SomeViewModel : ReactiveObject
{
    public SomeViewModel(IScheduler scheduler)
    {
        this.CancelableCommand = ReactiveCommand
            .CreateFromObservable(
                () => Observable
                    .StartAsync(DoSomethingAsync)
                    .TakeUntil(CancelCommand), outputScheduler: scheduler);
        this.CancelCommand = ReactiveCommand.Create(
            () =>
            {
                Debug.WriteLine("Cancelling");
            },
            this.CancelableCommand.IsExecuting, scheduler);
    }

    public ReactiveCommand<Unit, Unit> CancelableCommand
    {
        get;
        private set;
    }

    public ReactiveCommand<Unit, Unit> CancelCommand
    {
        get;
        private set;
    }

    public bool IsCancelled { get; private set; }

    private async Task DoSomethingAsync(CancellationToken ct)
    {
        try
        {
            await Task.Delay(TimeSpan.FromSeconds(3), ct);
        }
        catch (TaskCanceledException)
        {
            IsCancelled = true;
        }
    }
}

And here is the unit test:

[TestFixture]
[Category("ViewModels")]
public class SomeViewModelFixture
{
    public async Task Executing_cancel_should_cancel_cancelableTask()
    {
        var sut = new SomeViewModel(Scheduler.Immediate);
        var t = sut.CancelableCommand.Execute();
        await sut.CancelCommand.Execute();

        await t;

        Assert.IsTrue(sut.IsCancelled);
    }
}

The CancelCommand is excuted (a breakpoint on the Console log is hit) however the Task.Delay is never cancelled. It seems TakeUntil doesn't request the cancellation.

UPDATE
I edited the code above so that my ViewModel ctor takes a IScheduler and create the commands with it as per that issue about unit testing but the test still fails.
I tried both nUnit and xUnit.
I also tried to do RxApp.MainThreadScheduler = Scheduler.Immediate in my test setup as per that article but still fails.

UPDATE2
From the solution that I marked as the answer and the comments, the simplest is not to use IScheduler in the ctor and then to write the test like that and it passes.

[Test]
    public async Task Executing_cancel_should_cancel_cancelableTask()
    {
        var sut = new SomeViewModel();
        sut.CancelableCommand.Execute().Subscribe();
        await sut.CancelCommand.Execute();

        Assert.IsTrue(sut.IsCancelled);
    }

Answer 1

This is working for me:

public class SomeViewModelTest
{
    SomeViewModel m_actual;

    [SetUp]
    public void Setup()
    {
        m_actual = new SomeViewModel(CurrentThreadScheduler.Instance); 
        m_actual.Activator.Activate();
    }

    [Test]
    public void Executing_cancel_should_cancel_cancelableTask()
    {
        m_actual.CancelableCommand.Execute().Subscribe();
        m_actual.CancelCommand.Execute().Subscribe();

        Assert.IsTrue(m_actual.IsCancelled);
    } 
}

I changed the scheduler to use the same from the test itself and my ViewModel does implement the ISupportsActivation, that I dare to say won't do any diference here. Other then that, I removed the async/await from the test, you don't need that with Rx, and just subscribed to the command.

Answer 2

The problem is that you're awaiting the execution of the command after you cancel it. Since the cancellation occurs before the command executes, it doesn't affect the command's execution. You can get it to pass as follows:

public async Task Executing_cancel_should_cancel_cancelableTask()
{
    var sut = new SomeViewModel(Scheduler.Immediate);
    sut.CancelableCommand.Execute().Subscribe();
    await sut.CancelCommand.Execute();

    Assert.True(sut.IsCancelled);
}

Here I'm starting the execution of the command immediately (by subscribing). The subsequent cancellation then affects that execution.

As a general note, it's always a bit messy mixing Rx and TPL. It works, but there are pitfalls and nasties like this lurking around every corner. As a longer-term solution, I'd highly recommend moving to "pure" Rx. You won't look back - it's amazing.