public async Task ViewModel_WhenRefreshed_ShouldDisposePreviousNotificationsSubscriptions( IFixture fixture, TestSchedulers scheduler, int[] values) { //arrange var notifications = scheduler.CreateColdObservable <int>(); var sut = new UpdatableObservableViewModelBuilderOptions <int, int[], int>( _ => { }, ct => Task.FromResult(values), () => notifications, scheduler, scheduler, scheduler) .UpdateAction((i, o) => () => { }) .ToViewModel(); const long disposeTime = 805; //act scheduler.Start(); await sut.RefreshAsync(); //we advance to an arbitrary time scheduler.AdvanceBy(disposeTime); //the subscription to the new observable should happen here //the first subscription should be dispose at the current scheduler time await sut.RefreshAsync(); //assert notifications.Subscriptions[0].Unsubscribe.Should().Be(disposeTime); }
public async Task ViewModel_WhenEmpty_WithRefreshOnCollectionUpdateNotification_ShouldRefresh( IFixture fixture, TestSchedulers scheduler, int[] expectedValue) { //arrange var notifications = scheduler.CreateColdObservable(OnNext(200, 1)); var observer = scheduler.CreateObserver <ObservableViewModelNotification>(); var count = 0; var sut = new UpdatableObservableViewModelBuilderOptions <int, int[], int>( _ => { }, ct => Task.FromResult(expectedValue), () => notifications, scheduler, scheduler, scheduler) .UpdateAction((i, o) => () => { }) .RefreshOnCollectionUpdateNotification() .EmptyPredicate(_ => ++ count == 1) .ToViewModel(); sut.Subscribe(observer); //act await sut.RefreshAsync(); scheduler.AdvanceBy(300); //assert observer.Values().Last().Value.As <ObservableCollection <int> >().ShouldAllBeEquivalentTo(expectedValue); }
public async Task ViewModel_ShouldReturnCorrectValue( IFixture fixture, TestSchedulers scheduler) { //arrange const int insertionIndex = 5; var initialList = fixture.CreateMany <int>(10).ToArray(); var addedList = fixture.CreateMany <int>(10).ToArray(); var expected = initialList.Take(insertionIndex) .Concat(addedList.Reverse()) .Concat(initialList.Skip(insertionIndex)) .ToArray(); var notifications = scheduler.CreateColdObservable(addedList.Select((i, ii) => OnNext(Subscribed + 1 + ii, i)).ToArray()); var sut = new UpdatableObservableViewModelBuilderOptions <int, int[], int>( _ => { }, ct => Task.FromResult(initialList), () => notifications, scheduler, scheduler, scheduler) .UpdateAction((i, o) => () => o.Insert(insertionIndex, i)) .ToViewModel(); //act scheduler.Start(); await sut.RefreshAsync(); scheduler.AdvanceBy(Disposed); var actual = ((IObservableViewModel <ObservableCollection <int> >)sut).CurrentValue; //assert actual.ShouldAllBeEquivalentTo(expected); }
public void Execute_WithObservableYielding3Values_ShouldReturnCorrectResult( object value1, object value2, object value3, TestSchedulers schedulers, ThrowingTestScheduler scheduler) { //arrange var observable = scheduler.CreateColdObservable(OnNext(10, value1), OnNext(20, value2), OnNext(30, value3), OnCompleted(40, new object())); var observer = scheduler.CreateObserver <object>(); var sut = new ObservableMvvmCommand <object, object>(o => observable, schedulers, schedulers, "name", new AlwaysTrueCanExecuteStrategy <object>(), doObserver: () => observer, doScheduler: ImmediateScheduler.Instance); //act sut.Execute(null); //allow any work scheduled with the schedulers to advance schedulers.AdvanceBy(200); //allow notifications to advance scheduler.AdvanceBy(200); //assert observer.Messages.AssertEqual(OnNext(10, value1), OnNext(20, value2), OnNext(30, value3), OnCompleted(40, new object())); }
public void Execute_WhenExuctingWhileOtherExecutionIsOccuring_ShouldCancelPreviousExecution( [Frozen] TestSchedulers schedulers) { //arrange var firstObservable = schedulers.CreateColdObservable(OnNext(200, new object()), OnNext(300, new object())); var secondObservable = schedulers.CreateColdObservable(OnNext(400, new object()), OnNext(500, new object())); var i = 0; Func <object, IObservable <object> > observableFactory = _ => ++ i == 1 ? firstObservable : secondObservable; var sut = new ObservableMvvmCommand <object, object>(observableFactory, schedulers, schedulers, "name", new AlwaysTrueCanExecuteStrategy <object>()); //act sut.Execute(null); schedulers.AdvanceBy(250); sut.Execute(null); schedulers.AdvanceBy(350); //assert firstObservable.Subscriptions.Single().Unsubscribe.Should().Be(250); }
public void Execute_ShouldCallNotifyExecuting( [Frozen] Mock <ICanExecuteStrategy <object> > canExecute, ObservableMvvmCommand <object, object> sut, [Frozen] object obj, TestSchedulers schedulers) { //arrange //act sut.Execute(obj); schedulers.AdvanceBy(200); //assert canExecute.Verify(c => c.NotifyExecuting(obj), Times.Once()); }
public void CanExecuteChanged_WhenCanExecuteStrategyObservableYieldValue_ShouldBeRaiseCanExecute( [Frozen] Subject <Unit> canExecuteChanged, [Frozen] TestSchedulers schedulers, ObservableMvvmCommand <object, object> sut ) { //arrange sut.MonitorEvents(); //act canExecuteChanged.OnNext(Unit.Default); schedulers.AdvanceBy(200); //assert sut.ShouldRaise("CanExecuteChanged"); }
public void Execute_WhenComplete_ShouldCallNotifyNotExecuting( Mock <ICanExecuteStrategy <object> > canExecute, object obj, TestSchedulers schedulers) { //arrange var value = Observable.Return(obj, ImmediateScheduler.Instance); var sut = new ObservableMvvmCommand <object, object>(_ => value, schedulers, schedulers, "name", canExecute.Object); //act sut.Execute(obj); schedulers.AdvanceBy(200); //assert canExecute.Verify(c => c.NotifyNotExecuting(obj), Times.Once()); }
public void Execute_ShouldExecuteObservable( TestSchedulers schedulers) { //arrange bool observableCalled = false; var value = Observable.Return(Unit.Default, ImmediateScheduler.Instance) .Do(unit => observableCalled = true); var sut = new ObservableMvvmCommand <object, System.Reactive.Unit>(o => value, schedulers, schedulers, "name", new AlwaysTrueCanExecuteStrategy <object>()); //act sut.Execute(null); schedulers.AdvanceBy(200); //assert observableCalled.Should().BeTrue(); }
public void Execute_WithError_ShouldExecuteErrorTask( object obj, Exception expected, TestSchedulers schedulers) { //arrange Exception actual = null; var value = Observable.Throw <object>(expected, ImmediateScheduler.Instance); Func <CancellationToken, Exception, Task> errorTask = async(ct, ex) => actual = ex; var sut = new ObservableMvvmCommand <object, object>(_ => value, schedulers, schedulers, "name", new AlwaysTrueCanExecuteStrategy <object>(), errorTask: errorTask); //act sut.Execute(obj); schedulers.AdvanceBy(200); //assert actual.Should().Be(expected); }
public void Execute_WhenErrorInErrorAction_ShouldCallNotifyNotExecuting( Mock <ICanExecuteStrategy <object> > canExecute, Exception error, object obj, TestSchedulers schedulers) { //arrange var value = Observable.Throw <object>(error, ImmediateScheduler.Instance); Func <CancellationToken, Exception, Task> errorTask = async(ct, ex) => { throw new Exception(); }; var sut = new ObservableMvvmCommand <object, object>(_ => value, schedulers, schedulers, "name", canExecute.Object, errorTask: errorTask); //act sut.Execute(obj); schedulers.AdvanceBy(200); //assert canExecute.Verify(c => c.NotifyNotExecuting(obj), Times.Once()); }
public void Execute_ShouldCallOnError( Exception expected, TestSchedulers schedulers) { //arrange Exception actual = null; var value = Observable.Throw <object>(expected, ImmediateScheduler.Instance); var sut = new ObservableMvvmCommand <object, object>( o => value, schedulers, schedulers, "name", new AlwaysTrueCanExecuteStrategy <object>(), doObserver: () => Observer.Create <object>(_ => { }, e => actual = e), doScheduler: ImmediateScheduler.Instance); //act sut.Execute(null); schedulers.AdvanceBy(200); //assert actual.Should().Be(expected); }
public void Execute_ShouldCallCallback( object expected, TestSchedulers schedulers) { //arrange object actual = null; var value = Observable.Return(expected, ImmediateScheduler.Instance); var sut = new ObservableMvvmCommand <object, object>( o => value, schedulers, schedulers, "name", new AlwaysTrueCanExecuteStrategy <object>(), doObserver: () => Observer.Create <object>(o => actual = o), doScheduler: ImmediateScheduler.Instance); //act sut.Execute(null); schedulers.AdvanceBy(200); //assert actual.Should().Be(expected); }
public void Execute_ShouldBeCalledWithArg( IObservable <object> value, object arg, TestSchedulers schedulers) { //arrange object actual = null; var sut = new ObservableMvvmCommand <object, object>(o => { actual = o; return(value); }, schedulers, schedulers, "name", new AlwaysTrueCanExecuteStrategy <object>()); //act sut.Execute(arg); schedulers.AdvanceBy(200); //assert actual.Should().Be(arg); }