using System;

using System.Collections.Generic;

using System.Linq;

using System.Reactive;

using System.Reactive.Concurrency;

using System.Reactive.Linq;

using System.Reactive.Subjects;

using System.Reactive.Threading.Tasks;

using System.Threading;

using System.Threading.Tasks;

using ReactiveUI.Testing;

using Microsoft.Reactive.Testing;

using Xunit;

namespace ReactiveUI.Tests

{

public class ReactiveCommandInterfaceTest

{

protected ReactiveCommand<object> createCommand(IObservable<bool> canExecute, IScheduler scheduler = null)

{

return ReactiveCommand.Create(canExecute, scheduler);

}

[Fact]

public void CompletelyDefaultReactiveCommandShouldFire()

{

var sched = new TestScheduler();

var fixture = createCommand(null, sched);

Assert.True(fixture.CanExecute(null));

string result = null;

fixture.Subscribe(x => result = x as string);

fixture.Execute("Test");

sched.Start();

Assert.Equal("Test", result);

fixture.Execute("Test2");

sched.Start();

Assert.Equal("Test2", result);

}

[Fact]

public void ObservableCanExecuteShouldShowUpInCommand()

{

var input = new[] {true, false, false, true, false, true};

var result = (new TestScheduler()).With(sched => {

var can_execute = new Subject<bool>();

var fixture = createCommand(can_execute, sched);

var changes_as_observable = fixture.CanExecuteObservable.CreateCollection();

int change_event_count = 0;

fixture.CanExecuteChanged += (o, e) => { change_event_count++; };

input.Run(x => {

can_execute.OnNext(x);

sched.Start();

Assert.Equal(x, fixture.CanExecute(null));

});

// N.B. We check against '5' instead of 6 because we're supposed to

// suppress changes that aren't actually changes i.e. false => false

sched.AdvanceToMs(10*1000);

return changes_as_observable;

});

// NB: Skip(1) is because CanExecuteObservable should have

// BehaviorSubject Nature(tm)

input.DistinctUntilChanged().AssertAreEqual(result.Skip(1).ToList());

}

[Fact]

public void ObservableExecuteFuncShouldBeObservableAndAct()

{

var executed_params = new List<object>();

var fixture = createCommand(null);

fixture.Subscribe(x => executed_params.Add(x));

var observed_params = new ReplaySubject<object>();

fixture.Subscribe(observed_params.OnNext, observed_params.OnError, observed_params.OnCompleted);

var range = Enumerable.Range(0, 5);

range.Run(x => fixture.Execute(x));

range.AssertAreEqual(executed_params.OfType<int>());

range.ToObservable()

.Zip(observed_params, (expected, actual) => new {expected, actual})

.Do(Console.WriteLine)

.Subscribe(x => Assert.Equal(x.expected, x.actual));

}

[Fact]

public void ObservableCanExecuteIsNotNullAfterCanExecuteCalled()

{

var fixture = createCommand(null);

fixture.CanExecute(null);

Assert.NotNull(fixture.CanExecuteObservable);

}

[Fact]

public void ObservableCanExecuteIsNotNullAfterCanExecuteChangedEventAdded()

{

var fixture = createCommand(null);

fixture.CanExecuteChanged += (sender, args) => { };

Assert.NotNull(fixture.CanExecuteObservable);

}

[Fact]

public void MultipleSubscribesShouldntResultInMultipleNotifications()

{

var input = new[] {1, 2, 1, 2};

var sched = new TestScheduler();

var fixture = createCommand(null, sched);

var odd_list = new List<int>();

var even_list = new List<int>();

fixture.Where(x => ((int)x)%2 != 0).Subscribe(x => odd_list.Add((int)x));

fixture.Where(x => ((int)x)%2 == 0).Subscribe(x => even_list.Add((int)x));

input.Run(x => fixture.Execute(x));

sched.AdvanceToMs(1000);

new[] {1, 1}.AssertAreEqual(odd_list);

new[] {2, 2}.AssertAreEqual(even_list);

}

[Fact]

public void CanExecuteExceptionShouldntPermabreakCommands()

{

var canExecute = new Subject<bool>();

var fixture = createCommand(canExecute);

var exceptions = new List<Exception>();

var canExecuteStates = new List<bool>();

fixture.CanExecuteObservable.Subscribe(canExecuteStates.Add);

fixture.ThrownExceptions.Subscribe(exceptions.Add);

canExecute.OnNext(false);

Assert.False(fixture.CanExecute(null));

canExecute.OnNext(true);

Assert.True(fixture.CanExecute(null));

canExecute.OnError(new Exception("Aieeeee!"));

// The command should latch to false forever

Assert.False(fixture.CanExecute(null));

Assert.Equal(1, exceptions.Count);

Assert.Equal("Aieeeee!", exceptions[0].Message);

Assert.Equal(false, canExecuteStates[canExecuteStates.Count - 1]);

Assert.Equal(true, canExecuteStates[canExecuteStates.Count - 2]);

}

[Fact]

public void NoSubscriberOfThrownExceptionsEqualsDeath()

{

(new TestScheduler()).With(sched => {

var canExecute = new Subject<bool>();

var fixture = createCommand(canExecute, sched);

var result = fixture.CanExecuteObservable.CreateCollection();

bool failed = true;

try {

sched.AdvanceByMs(10);

canExecute.OnNext(true);

canExecute.OnError(new Exception("Aieeeee!"));

sched.AdvanceByMs(10);

// NB: canExecute failing should bring us down

Assert.True(false);

} catch (Exception ex) {

failed = (ex.InnerException.Message != "Aieeeee!");

}

Assert.False(failed);

});

}

[Fact]

public async Task ExecuteAsyncThrowsExceptionOnError()

{

var command = ReactiveCommand.CreateAsyncObservable(_ =>

Observable.Throw<Unit>(new Exception("Aieeeee!")));

var exceptions = command.ThrownExceptions.CreateCollection();

bool failed = false;

try {

await command.ExecuteAsync();

} catch (Exception ex) {

failed = ex.Message == "Aieeeee!";

}

Assert.True(failed);

Assert.Equal(1, exceptions.Count);

Assert.Equal("Aieeeee!", exceptions[0].Message);

}

[Fact]

public void ExecuteDoesntThrowOnError()

{

var command = ReactiveCommand.CreateAsyncObservable(_ =>

Observable.Throw<Unit>(new Exception("Aieeeee!")));

command.ThrownExceptions.Subscribe();

command.Execute(null);

}

}

public class ReactiveAsyncCommandTest

{

[Fact]

public void RegisterAsyncFunctionSmokeTest()

{

(new TestScheduler()).With(sched => {

var fixture = ReactiveCommand.CreateAsyncObservable(Observable.Return(true),

_ => Observable.Return(5).Delay(TimeSpan.FromSeconds(5), sched));

IReactiveDerivedList<int> results;

results = fixture.CreateCollection();

var inflightResults = fixture.IsExecuting.CreateCollection();

sched.AdvanceToMs(10);

Assert.True(fixture.CanExecute(null));

fixture.Execute(null);

sched.AdvanceToMs(1005);

Assert.False(fixture.CanExecute(null));

sched.AdvanceToMs(5100);

Assert.True(fixture.CanExecute(null));

new[] {false, true, false}.AssertAreEqual(inflightResults);

new[] {5}.AssertAreEqual(results);

});

}

[Fact]

public void MultipleSubscribersShouldntDecrementRefcountBelowZero()

{

(new TestScheduler()).With(sched => {

var fixture = ReactiveCommand.CreateAsyncObservable(Observable.Return(true),

_ => Observable.Return(5).Delay(TimeSpan.FromMilliseconds(5000), sched));

var results = new List<int>();

bool[] subscribers = new[] {false, false, false, false, false};

fixture.Subscribe(x => results.Add(x));

Enumerable.Range(0, 5).Run(x => fixture.Subscribe(_ => subscribers[x] = true));

Assert.True(fixture.CanExecute(null));

fixture.Execute(null);

sched.AdvanceToMs(2000);

Assert.False(fixture.CanExecute(null));

sched.AdvanceToMs(6000);

Assert.True(fixture.CanExecute(null));

Assert.True(results.Count == 1);

Assert.True(results[0] == 5);

Assert.True(subscribers.All(x => x));

});

}

[Fact]

public void MultipleResultsFromObservableShouldntDecrementRefcountBelowZero()

{

(new TestScheduler()).With(sched => {

bool latestExecuting = false;

var fixture = ReactiveCommand.CreateAsyncObservable(Observable.Return(true),

_ => new[] {1, 2, 3}.ToObservable(),

sched);

var results = fixture.CreateCollection();

fixture.IsExecuting.Subscribe(x => latestExecuting = x);

fixture.Execute(1);

sched.Start();

Assert.Equal(3, results.Count);

Assert.Equal(false, latestExecuting);

});

}

[Fact]

public void CanExecuteShouldChangeOnInflightOp()

{

(new TestScheduler()).With(sched => {

var canExecute = sched.CreateHotObservable(

sched.OnNextAt(0, true),

sched.OnNextAt(250, false),

sched.OnNextAt(500, true),

sched.OnNextAt(750, false),

sched.OnNextAt(1000, true),

sched.OnNextAt(1100, false)

);

var fixture = ReactiveCommand.CreateAsyncObservable(canExecute,

x => Observable.Return((int)x * 5).Delay(TimeSpan.FromMilliseconds(900), RxApp.MainThreadScheduler));

int calculatedResult = -1;

bool latestCanExecute = false;

fixture.Subscribe(x => calculatedResult = x);

fixture.CanExecuteObservable.Subscribe(x => latestCanExecute = x);

// CanExecute should be true, both input observable is true

// and we don't have anything inflight

sched.AdvanceToMs(10);

Assert.True(fixture.CanExecute(1));

Assert.True(latestCanExecute);

// Invoke a command 10ms in

fixture.Execute(1);

// At 300ms, input is false

sched.AdvanceToMs(300);

Assert.False(fixture.CanExecute(1));

Assert.False(latestCanExecute);

// At 600ms, input is true, but the command is still running

sched.AdvanceToMs(600);

Assert.False(fixture.CanExecute(1));

Assert.False(latestCanExecute);

// After we've completed, we should still be false, since from

// 750ms-1000ms the input observable is false

sched.AdvanceToMs(900);

Assert.False(fixture.CanExecute(1));

Assert.False(latestCanExecute);

Assert.Equal(-1, calculatedResult);

sched.AdvanceToMs(1010);

Assert.True(fixture.CanExecute(1));

Assert.True(latestCanExecute);

Assert.Equal(calculatedResult, 5);

sched.AdvanceToMs(1200);

Assert.False(fixture.CanExecute(1));

Assert.False(latestCanExecute);

});

}

[Fact]

public void DisallowConcurrentExecutionTest()

{

(new TestScheduler()).With(sched => {

var fixture = ReactiveCommand.CreateAsyncObservable(Observable.Return(true),

_ => Observable.Return(4).Delay(TimeSpan.FromSeconds(5), sched),

sched);

Assert.True(fixture.CanExecute(null));

var result = fixture.CreateCollection();

Assert.Equal(0, result.Count);

sched.AdvanceToMs(25);

Assert.Equal(0, result.Count);

fixture.Execute(null);

Assert.False(fixture.CanExecute(null));

Assert.Equal(0, result.Count);

sched.AdvanceToMs(2500);

Assert.False(fixture.CanExecute(null));

Assert.Equal(0, result.Count);

sched.AdvanceToMs(5500);

Assert.True(fixture.CanExecute(null));

Assert.Equal(1, result.Count);

});

}

[Fact]

public void CombinedCommandsShouldFireChildCommands()

{

var cmd1 = ReactiveCommand.Create();

var cmd2 = ReactiveCommand.Create();

var cmd3 = ReactiveCommand.Create();

var output = new[] { cmd1, cmd2, cmd3, }.Merge().CreateCollection();

var fixture = ReactiveCommand.CreateCombined(cmd1, cmd2, cmd3);

Assert.True(fixture.CanExecute(null));

Assert.Equal(0, output.Count);

fixture.Execute(42);

Assert.Equal(3, output.Count);

}

[Fact]

public void CombinedCommandsShouldReflectCanExecuteOfChildren()

{

var subj1 = new Subject<bool>();

var cmd1 = ReactiveCommand.Create(subj1);

var subj2 = new Subject<bool>();

var cmd2 = ReactiveCommand.Create(subj2);

var cmd3 = ReactiveCommand.Create();

// Initial state for ReactiveCommands is to be executable

var fixture = ReactiveCommand.CreateCombined(cmd1, cmd2, cmd3);

var canExecuteOutput = fixture.CanExecuteObservable.CreateCollection();

// cmd1 and cmd2 are ??? so, result is false

Assert.False(fixture.CanExecute(null));

Assert.Equal(1, canExecuteOutput.Count);

// 1 is false, 2 is true

subj1.OnNext(false);

Assert.False(fixture.CanExecute(null));

Assert.Equal(1, canExecuteOutput.Count);

Assert.Equal(false, canExecuteOutput[0]);

// 1 is false, 2 is false

subj2.OnNext(false);

Assert.False(fixture.CanExecute(null));

Assert.Equal(1, canExecuteOutput.Count);

// 1 is true, 2 is false

subj1.OnNext(true);

Assert.False(fixture.CanExecute(null));

Assert.Equal(1, canExecuteOutput.Count);

// 1 is true, 2 is true

subj2.OnNext(true);

Assert.True(fixture.CanExecute(null));

Assert.Equal(2, canExecuteOutput.Count);

Assert.Equal(true, canExecuteOutput[1]);

}

[Fact]

public void CombinedCommandsShouldBeInactiveOnAsyncInflightOps()

{

(new TestScheduler()).With(sched => {

var cmd1 = ReactiveCommand.CreateAsyncObservable(Observable.Return(true),

x => Observable.Return(x).Delay(TimeSpan.FromMilliseconds(100), sched));

var cmd2 = ReactiveCommand.CreateAsyncObservable(Observable.Return(true),

x => Observable.Return(x).Delay(TimeSpan.FromMilliseconds(300), sched));

var cmd3 = ReactiveCommand.Create();

var result1 = cmd1.CreateCollection();

var result2 = cmd2.CreateCollection();

var fixture = ReactiveCommand.CreateCombined(cmd1, cmd2, cmd3);

var canExecuteOutput = fixture.CanExecuteObservable.CreateCollection();

Assert.True(fixture.CanExecute(null));

Assert.Equal(0, canExecuteOutput.Count);

fixture.Execute(42);

// NB: The first two canExecuteOutputs are because of the initial value

// that shows up because we finally ran the scheduler

sched.AdvanceToMs(50.0);

Assert.Equal(2, canExecuteOutput.Count);

Assert.Equal(true, canExecuteOutput[0]);

Assert.Equal(false, canExecuteOutput[1]);

Assert.Equal(false, fixture.CanExecute(null));

Assert.Equal(0, result1.Count);

Assert.Equal(0, result2.Count);

sched.AdvanceToMs(250.0);

Assert.Equal(2, canExecuteOutput.Count);

Assert.Equal(false, fixture.CanExecute(null));

Assert.Equal(1, result1.Count);

Assert.Equal(0, result2.Count);

sched.AdvanceToMs(500.0);

Assert.Equal(3, canExecuteOutput.Count);

Assert.Equal(true, canExecuteOutput[2]);

Assert.Equal(true, fixture.CanExecute(null));

Assert.Equal(1, result1.Count);

Assert.Equal(1, result2.Count);

});

}

[Fact]

public void CombinedCommandsShouldReflectParentCanExecute()

{

var subj1 = new Subject<bool>();

var cmd1 = ReactiveCommand.Create(subj1);

var subj2 = new Subject<bool>();

var cmd2 = ReactiveCommand.Create(subj2);

var cmd3 = ReactiveCommand.Create();

var parentSubj = new Subject<bool>();

// Initial state for ReactiveCommands is to be executable

var fixture = ReactiveCommand.CreateCombined(parentSubj, cmd1, cmd2, cmd3);

var canExecuteOutput = fixture.CanExecuteObservable.CreateCollection();

Assert.False(fixture.CanExecute(null));

Assert.Equal(1, canExecuteOutput.Count);

parentSubj.OnNext(false);

// 1 is false, 2 is true

subj1.OnNext(false);

Assert.False(fixture.CanExecute(null));

Assert.Equal(1, canExecuteOutput.Count);

Assert.Equal(false, canExecuteOutput[0]);

// 1 is false, 2 is false

subj2.OnNext(false);

Assert.False(fixture.CanExecute(null));

Assert.Equal(1, canExecuteOutput.Count);

// 1 is true, 2 is false

subj1.OnNext(true);

Assert.False(fixture.CanExecute(null));

Assert.Equal(1, canExecuteOutput.Count);

// 1 is true, 2 is true, but it doesn't matter because

// parent is still false

subj2.OnNext(true);

Assert.False(fixture.CanExecute(null));

Assert.Equal(1, canExecuteOutput.Count);

// Parent is finally true, mark it true

parentSubj.OnNext(true);

Assert.True(fixture.CanExecute(null));

Assert.Equal(2, canExecuteOutput.Count);

Assert.Equal(true, canExecuteOutput[1]);

}

[Fact]

public void TaskExceptionsShouldBeMarshaledToThrownExceptions()

{

(new TestScheduler()).With(sched => {

var fixture = ReactiveCommand.CreateAsyncTask(Observable.Return(true), async _ => {

await Observable.Timer(TimeSpan.FromMilliseconds(50), RxApp.TaskpoolScheduler);

throw new Exception("Die");

return 5;

}, sched);

int result = 0;

fixture.Subscribe(x => result = x);

var error = default(Exception);

fixture.ThrownExceptions.Subscribe(ex => error = ex);

fixture.Execute(null);

sched.AdvanceByMs(20);

Assert.Null(error);

Assert.Equal(0, result);

// NB: We have to Thread.Sleep here to compensate for not being

// able to control the concurrency of Task

sched.AdvanceByMs(100);

Thread.Sleep(100);

// NB: Advance it one more so that the scheduled ThrownExceptions

// end up being dispatched

sched.AdvanceByMs(10);

Assert.NotNull(error);

Assert.Equal(0, result);

});

}

[Fact]

public async Task IsExecutingIsFalseAfterAwaitingCommand()

{

var command = ReactiveCommand.CreateAsyncTask(_ => Task.Run(() => Thread.Sleep(10)));

var isExecutingStates = new List<bool>();

command.IsExecuting.Subscribe(isExecutingStates.Add);

await command.ExecuteAsync();

Assert.Equal(3, isExecutingStates.Count);

Assert.Equal(false, isExecutingStates[0]);

Assert.Equal(true, isExecutingStates[1]);

Assert.Equal(false, isExecutingStates[2]);

}

}

}