public void parse_error_message_is_null_if_a_document_is_successfully_parsed_after_one_fails_to_parse() { var badDocument = @"# First Program ## First Exercise whatever!"; var goodDocument = "# First Program"; var documents = new Subject <string>(); var exerciseDocumentService = new ExerciseDocumentServiceMock(); var scheduler = new TestScheduler(); exerciseDocumentService .When(x => x.ExerciseDocument) .Return(documents); var sut = new ExerciseProgramsViewModelBuilder() .WithExerciseDocumentService(exerciseDocumentService) .WithScheduler(scheduler) .Build(); documents.OnNext(badDocument); scheduler.AdvanceMinimal(); Assert.NotNull(sut.ParseErrorMessage); documents.OnNext(goodDocument); scheduler.AdvanceMinimal(); Assert.Null(sut.ParseErrorMessage); }
public void execution_context_is_cancelled_if_user_navigates_away() { var scheduler = new TestScheduler(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction( new WaitActionBuilder() .WithDelayService(new DelayServiceBuilder().Build()) .WithDelay(TimeSpan.FromMinutes(1)) .Build()))) .WithScheduler(scheduler) .Build(); sut .HostScreen .Router .NavigationStack .Add(sut); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.True(sut.IsStarted); sut .HostScreen .Router .NavigateBack .ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.False(sut.IsStarted); }
public void parse_error_message_is_null_if_a_document_is_successfully_parsed_after_one_fails_to_parse() { var badDocument = @"# First Program ## First Exercise whatever!"; var goodDocument = "# First Program"; var documents = new Subject<string>(); var exerciseDocumentService = new ExerciseDocumentServiceMock(); var scheduler = new TestScheduler(); exerciseDocumentService .When(x => x.ExerciseDocument) .Return(documents); var sut = new ExerciseProgramsViewModelBuilder() .WithExerciseDocumentService(exerciseDocumentService) .WithScheduler(scheduler) .Build(); documents.OnNext(badDocument); scheduler.AdvanceMinimal(); Assert.NotNull(sut.ParseErrorMessage); documents.OnNext(goodDocument); scheduler.AdvanceMinimal(); Assert.Null(sut.ParseErrorMessage); }
public void progress_time_span_is_not_reset_to_zero_if_another_exercise_is_started() { var scheduler = new TestScheduler(); var model1 = new ExerciseBuilder() .WithName("model 1") .Build(); var model2 = new ExerciseBuilder() .WithName("model 2") .Build(); var executionContext = new ExecutionContext(); var sut = new ExerciseViewModelBuilder() .WithSchedulerService(scheduler) .WithExecutionContext(executionContext) .WithModel(model1) .Build(); executionContext.SetCurrentExercise(model1); executionContext.AddProgress(TimeSpan.FromSeconds(3)); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan); executionContext.SetCurrentExercise(model2); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan); executionContext.AddProgress(TimeSpan.FromSeconds(3)); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan); }
public void is_resume_visible_cycles_correctly_if_start_command_is_executed_and_execution_is_paused() { var scheduler = new TestScheduler(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction( new WaitActionBuilder() .WithDelayService(new DelayServiceBuilder().Build()) .WithDelay(TimeSpan.FromMinutes(1)) .Build()))) .WithScheduler(scheduler) .Build(); var isResumeVisible = sut .WhenAnyValue(x => x.IsResumeVisible) .CreateCollection(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); sut.PauseCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(2, isResumeVisible.Count); Assert.False(isResumeVisible[0]); Assert.True(isResumeVisible[1]); }
public void progress_time_span_reflects_any_progression_through_the_exercise() { var scheduler = new TestScheduler(); var model = new ExerciseBuilder() .Build(); var executionContext = new ExecutionContext(); var sut = new ExerciseViewModelBuilder() .WithSchedulerService(scheduler) .WithExecutionContext(executionContext) .WithModel(model) .Build(); executionContext.SetCurrentExercise(model); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.Zero, sut.ProgressTimeSpan); executionContext.AddProgress(TimeSpan.FromSeconds(3)); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan); executionContext.AddProgress(TimeSpan.FromSeconds(2)); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.FromSeconds(5), sut.ProgressTimeSpan); }
public void current_exercise_reflects_that_in_the_execution_context() { var scheduler = new TestScheduler(); var action = new ActionMock(); action .When(x => x.Duration) .Return(TimeSpan.FromSeconds(10)); action .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Return <ExecutionContext>( ec => { ec.IsPaused = true; return(ec.WaitWhilePaused()); }); var exercise1 = new ExerciseBuilder() .WithName("Exercise 1") .WithBeforeExerciseAction(action) .Build(); var exercise2 = new ExerciseBuilder() .WithName("Exercise 2") .WithBeforeExerciseAction(action) .Build(); var exercise3 = new ExerciseBuilder() .WithName("Exercise 3") .WithBeforeExerciseAction(action) .Build(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(exercise1) .WithExercise(exercise2) .WithExercise(exercise3)) .WithScheduler(scheduler) .Build(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal("Exercise 1", sut.CurrentExercise?.Name); sut.SkipForwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal("Exercise 2", sut.CurrentExercise?.Name); sut.SkipForwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal("Exercise 3", sut.CurrentExercise?.Name); sut.SkipBackwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal("Exercise 2", sut.CurrentExercise?.Name); }
public void skip_backwards_command_restarts_the_execution_context_from_the_start_of_the_previous_exercise_if_the_current_exercise_if_only_recently_started() { var scheduler = new TestScheduler(); var action = new ActionMock(); action .When(x => x.Duration) .Return(TimeSpan.FromSeconds(10)); action .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Return <ExecutionContext>( ec => { ec.AddProgress(TimeSpan.FromSeconds(0.5)); ec.IsPaused = true; return(ec.WaitWhilePaused()); }); var exercise1 = new ExerciseBuilder() .WithName("Exercise 1") .WithBeforeExerciseAction(action) .Build(); var exercise2 = new ExerciseBuilder() .WithName("Exercise 2") .WithBeforeExerciseAction(action) .Build(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(exercise1) .WithExercise(exercise2)) .WithScheduler(scheduler) .Build(); var progress = sut .WhenAnyValue(x => x.ProgressTimeSpan) .CreateCollection(); // start from the second exercise sut.StartCommand.ExecuteAsync(exercise1.Duration); scheduler.AdvanceMinimal(); sut.SkipBackwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(5, progress.Count); Assert.Equal(TimeSpan.Zero, progress[0]); Assert.Equal(TimeSpan.FromSeconds(10), progress[1]); Assert.Equal(TimeSpan.FromSeconds(10.5), progress[2]); Assert.Equal(TimeSpan.Zero, progress[3]); Assert.Equal(TimeSpan.FromSeconds(10), progress[4]); }
public void skip_forwards_command_is_disabled_if_on_last_exercise() { var scheduler = new TestScheduler(); var action = new ActionMock(); action .When(x => x.Duration) .Return(TimeSpan.FromSeconds(10)); action .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Return <ExecutionContext>( ec => { ec.IsPaused = true; return(ec.WaitWhilePaused()); }); var exercise1 = new ExerciseBuilder() .WithName("Exercise 1") .WithBeforeExerciseAction(action) .Build(); var exercise2 = new ExerciseBuilder() .WithName("Exercise 2") .WithBeforeExerciseAction(action) .Build(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(exercise1) .WithExercise(exercise2)) .WithScheduler(scheduler) .Build(); var canExecute = sut .SkipForwardsCommand .CanExecute .CreateCollection(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); sut.SkipForwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(5, canExecute.Count); Assert.False(canExecute[0]); Assert.True(canExecute[1]); Assert.False(canExecute[2]); Assert.True(canExecute[3]); Assert.False(canExecute[4]); }
public void skip_forwards_command_skips_to_the_next_exercise() { var scheduler = new TestScheduler(); var action = new ActionMock(); action .When(x => x.Duration) .Return(TimeSpan.FromSeconds(10)); action .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Return <ExecutionContext>( ec => { ec.IsPaused = true; return(ec.WaitWhilePaused()); }); var exercise1 = new ExerciseBuilder() .WithName("Exercise 1") .WithBeforeExerciseAction(action) .Build(); var exercise2 = new ExerciseBuilder() .WithName("Exercise 2") .WithBeforeExerciseAction(action) .Build(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(exercise1) .WithExercise(exercise2)) .WithScheduler(scheduler) .Build(); var progress = sut .WhenAnyValue(x => x.ProgressTimeSpan) .CreateCollection(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); sut.SkipForwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(2, progress.Count); Assert.Equal(TimeSpan.Zero, progress[0]); Assert.Equal(TimeSpan.FromSeconds(10), progress[1]); }
public void document_is_not_stored_in_cache_if_loaded_from_cache() { var document = "# First Program"; var scheduler = new TestScheduler(); var stateService = new StateServiceMock(); stateService .When(x => x.Get <string>(It.IsAny <string>())) .Return(Observable.Return(document)); stateService .When(x => x.Set <string>(It.IsAny <string>(), It.IsAny <string>())) .Return(Observable.Return(Unit.Default)); var sut = new ExerciseProgramsViewModelBuilder() .WithScheduler(scheduler) .WithStateService(stateService) .Build(); scheduler.AdvanceMinimal(); Assert.Equal(ExerciseProgramsViewModelStatus.LoadedFromCache, sut.Status); stateService .Verify(x => x.Set <string>("ExerciseProgramsDocument", document)) .WasNotCalled(); }
public void delete_all_deletes_all_entities_on_provided_scheduler() { var scheduler = new TestScheduler(); var repository = new RepositoryMock <int, TestEntity>(MockBehavior.Loose); repository .When(x => x.Get(42)) .Return(new TestEntity()); var sut = new AsyncRepositoryBuilder() .WithDataStoreScheduler(scheduler) .WithRepository(repository) .Build(); sut .DeleteAll() .Subscribe(); repository .Verify(x => x.DeleteAll()) .WasNotCalled(); scheduler.AdvanceMinimal(); repository .Verify(x => x.DeleteAll()) .WasCalledExactlyOnce(); }
public void items_retrieves_entities_on_provided_scheduler() { var scheduler = new TestScheduler(); var repository = new RepositoryMock <int, TestEntity>(MockBehavior.Loose); repository .When(x => x.GetAll()) .Return(ImmutableList <TestEntity> .Empty); var sut = new AsyncRepositoryBuilder() .WithDataStoreScheduler(scheduler) .WithRepository(repository) .Build(); sut .Items .Subscribe(); repository .Verify(x => x.GetAll()) .WasNotCalled(); scheduler.AdvanceMinimal(); repository .Verify(x => x.GetAll()) .WasCalledExactlyOnce(); }
public void programs_is_populated_from_cache_whilst_document_from_cloud_loads() { var cacheDocument = "# First Program"; var cloudDocument = @" # First Program # Second Program"; var scheduler = new TestScheduler(); var exerciseDocumentService = new ExerciseDocumentServiceMock(MockBehavior.Loose); exerciseDocumentService .When(x => x.ExerciseDocument) .Return( Observable .Return(cloudDocument) .Delay(TimeSpan.FromSeconds(3), scheduler)); var sut = new ExerciseProgramsViewModelBuilder() .WithExerciseDocumentService(exerciseDocumentService) .WithCachedDocument(cacheDocument) .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.NotNull(sut.Programs); Assert.Equal(1, sut.Programs.Count); scheduler.AdvanceBy(TimeSpan.FromSeconds(2)); Assert.NotNull(sut.Programs); Assert.Equal(1, sut.Programs.Count); scheduler.AdvanceBy(TimeSpan.FromSeconds(2)); Assert.NotNull(sut.Programs); Assert.Equal(2, sut.Programs.Count); }
public void progress_is_calculated_based_on_duration_and_progress_time_span(int durationInMs, int progressInMs, double expectedProgress) { var scheduler = new TestScheduler(); var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Duration) .Return(TimeSpan.FromMilliseconds(durationInMs)); var model = new ExerciseBuilder() .WithBeforeExerciseAction(action) .Build(); var executionContext = new ExecutionContext(); var sut = new ExerciseViewModelBuilder() .WithSchedulerService(scheduler) .WithExecutionContext(executionContext) .WithModel(model) .Build(); executionContext.SetCurrentExercise(model); executionContext.AddProgress(TimeSpan.FromMilliseconds(progressInMs)); scheduler.AdvanceMinimal(); Assert.Equal(expectedProgress, sut.Progress); }
public void upgrade_records_versions() { var scheduler = new TestScheduler(); var dataStoreVersionRepository = new DataStoreVersionRepositoryMock(MockBehavior.Loose); var upgradeHandler1 = new UpgradeHandlerMock(MockBehavior.Loose); var upgradeHandler2 = new UpgradeHandlerMock(MockBehavior.Loose); upgradeHandler1 .When(x => x.Version) .Return(new Version(1, 0, 0)); upgradeHandler2 .When(x => x.Version) .Return(new Version(2, 0, 1)); var sut = new DataStoreServiceBuilder() .WithDataStoreScheduler(scheduler) .WithDataStoreVersionRepository(dataStoreVersionRepository) .WithUpgradeHandlers(upgradeHandler1, upgradeHandler2) .Build(); sut .Upgrade() .Subscribe(); scheduler.AdvanceMinimal(); dataStoreVersionRepository .Verify(x => x.Save(It.Matches <DataStoreVersionEntity>(y => y.Major == 1 && y.Minor == 0 && y.Build == 0))) .WasCalledExactlyOnce(); dataStoreVersionRepository .Verify(x => x.Save(It.Matches <DataStoreVersionEntity>(y => y.Major == 2 && y.Minor == 0 && y.Build == 1))) .WasCalledExactlyOnce(); }
public void skip_backwards_command_is_disabled_if_on_first_exercise() { var scheduler = new TestScheduler(); var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Return <ExecutionContext>( ec => { ec.IsPaused = true; return(ec.WaitWhilePaused()); }); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction(action))) .WithScheduler(scheduler) .Build(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.False(sut.SkipBackwardsCommand.CanExecute.FirstAsync().Wait()); }
public void is_pause_visible_cycles_correctly_if_start_command_is_executed() { var scheduler = new TestScheduler(); var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Duration) .Return(TimeSpan.FromMinutes(1)); action .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Return <ExecutionContext>( ec => Observable .Return(Unit.Default) .Do(_ => { }) .Delay(TimeSpan.FromMinutes(1), scheduler) .Do(_ => ec.AddProgress(TimeSpan.FromMinutes(1)))); var sut = new ExerciseProgramViewModelBuilder() .WithModel( new ExerciseProgramBuilder() .WithExercise( new ExerciseBuilder() .WithBeforeExerciseAction(action))) .WithScheduler(scheduler) .Build(); Assert.False(sut.IsPauseVisible); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.True(sut.IsPauseVisible); scheduler.AdvanceBy(TimeSpan.FromMinutes(10)); Assert.False(sut.IsPauseVisible); }
public void upgrade_aborts_if_any_upgrade_fails() { var scheduler = new TestScheduler(); var upgradeHandler1 = new UpgradeHandlerMock(MockBehavior.Loose); var upgradeHandler2 = new UpgradeHandlerMock(MockBehavior.Loose); upgradeHandler1 .When(x => x.Version) .Return(new Version(1, 0, 0)); upgradeHandler1 .When(x => x.Apply(It.IsAny <IDatabaseConnection>())) .Throw(); upgradeHandler2 .When(x => x.Version) .Return(new Version(2, 0, 0)); var sut = new DataStoreServiceBuilder() .WithDataStoreScheduler(scheduler) .WithUpgradeHandlers(upgradeHandler1, upgradeHandler2) .Build(); sut .Upgrade() .Subscribe(); scheduler.AdvanceMinimal(); upgradeHandler1 .Verify(x => x.Apply(sut.Connection)) .WasCalledExactlyOnce(); upgradeHandler2 .Verify(x => x.Apply(It.IsAny <IDatabaseConnection>())) .WasNotCalled(); }
public void upgrade_applies_relevant_upgrades_only(string[] existingVersions, string[] availableVersions, bool[] applyExpected) { Assert.Equal(availableVersions.Length, applyExpected.Length); var scheduler = new TestScheduler(); var versions = existingVersions .Select( x => new DataStoreVersionEntityBuilder() .WithVersion(Version.Parse(x)) .Build()) .ToImmutableList(); var dataStoreVersionRepository = new DataStoreVersionRepositoryMock(MockBehavior.Loose); dataStoreVersionRepository .When(x => x.GetAll()) .Return(versions); dataStoreVersionRepository .When(x => x.GetLatest()) .Return(versions.Last()); var upgradeHandlers = availableVersions .Select( x => { var mock = new UpgradeHandlerMock(MockBehavior.Loose); mock .When(y => y.Version) .Return(Version.Parse(x)); return(mock); }) .ToArray(); var sut = new DataStoreServiceBuilder() .WithDataStoreScheduler(scheduler) .WithDataStoreVersionRepository(dataStoreVersionRepository) .WithUpgradeHandlers(upgradeHandlers) .Build(); sut .Upgrade() .Subscribe(); scheduler.AdvanceMinimal(); for (var i = 0; i < availableVersions.Length; ++i) { var upgradeHandler = upgradeHandlers[i]; if (applyExpected[i]) { upgradeHandler .Verify(x => x.Apply(sut.Connection)) .WasCalledExactlyOnce(); } else { upgradeHandler .Verify(x => x.Apply(sut.Connection)) .WasNotCalled(); } } }
public void is_active_is_false_if_there_is_no_execution_context() { var scheduler = new TestScheduler(); var sut = new ExerciseViewModelBuilder() .WithSchedulerService(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.False(sut.IsActive); }
public void is_active_is_true_if_this_exercise_is_the_current_exercise() { var scheduler = new TestScheduler(); var model = new ExerciseBuilder() .Build(); var executionContext = new ExecutionContext(); var sut = new ExerciseViewModelBuilder() .WithSchedulerService(scheduler) .WithExecutionContext(executionContext) .WithModel(model) .Build(); scheduler.AdvanceMinimal(); Assert.False(sut.IsActive); executionContext.SetCurrentExercise(model); scheduler.AdvanceMinimal(); Assert.True(sut.IsActive); }
public void programs_is_null_if_both_cache_and_cloud_are_empty() { var scheduler = new TestScheduler(); var sut = new ExerciseProgramsViewModelBuilder() .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.Null(sut.Programs); }
public void is_start_visible_is_true_by_default() { var scheduler = new TestScheduler(); var sut = new ExerciseProgramViewModelBuilder() .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.True(sut.IsStartVisible); }
public void is_started_cycles_correctly_if_start_command_is_executed() { var scheduler = new TestScheduler(); var sut = new ExerciseProgramViewModelBuilder() .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); var isStarted = sut .WhenAnyValue(x => x.IsStarted) .CreateCollection(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(3, isStarted.Count); Assert.False(isStarted[0]); Assert.True(isStarted[1]); Assert.False(isStarted[2]); }
public void status_is_loaded_from_cloud_if_document_is_successfully_loaded_from_cloud() { var document = "# First Program"; var scheduler = new TestScheduler(); var sut = new ExerciseProgramsViewModelBuilder() .WithCloudDocument(document) .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.Equal(ExerciseProgramsViewModelStatus.LoadedFromService, sut.Status); }
public void skip_backwards_command_restarts_the_execution_context_from_the_start_of_the_current_exercise_if_sufficient_progress_has_been_made() { var scheduler = new TestScheduler(); var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Return <ExecutionContext>( ec => { ec.AddProgress(TimeSpan.FromSeconds(4)); ec.IsPaused = true; return(ec.WaitWhilePaused()); }); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction(action))) .WithScheduler(scheduler) .Build(); var progress = sut .WhenAnyValue(x => x.ProgressTimeSpan) .CreateCollection(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); sut.SkipBackwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(3, progress.Count); Assert.Equal(TimeSpan.Zero, progress[0]); Assert.Equal(TimeSpan.FromSeconds(4), progress[1]); Assert.Equal(TimeSpan.Zero, progress[2]); }
public void programs_is_populated_from_cloud_if_cache_is_empty_and_cloud_is_populated() { var document = "# First Program"; var scheduler = new TestScheduler(); var sut = new ExerciseProgramsViewModelBuilder() .WithCloudDocument(document) .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.NotNull(sut.Programs); Assert.Equal(1, sut.Programs.Count); }
public void progress_time_span_is_reset_to_zero_if_the_execution_context_changes_to_null() { var scheduler = new TestScheduler(); var model = new ExerciseBuilder() .Build(); var executionContext = new ExecutionContext(); var executionContextSubject = new Subject <ExecutionContext>(); var sut = new ExerciseViewModelBuilder() .WithSchedulerService(scheduler) .WithExecutionContext(executionContextSubject) .WithModel(model) .Build(); executionContextSubject.OnNext(executionContext); executionContext.SetCurrentExercise(model); executionContext.AddProgress(TimeSpan.FromSeconds(3)); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan); executionContextSubject.OnNext(null); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.Zero, sut.ProgressTimeSpan); }
public void programs_yields_any_successfully_parsed_programs() { var document = "# First Program"; var scheduler = new TestScheduler(); var sut = new ExerciseProgramsViewModelBuilder() .WithCloudDocument(document) .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.NotNull(sut.Programs); Assert.Equal(1, sut.Programs.Count); Assert.Equal("First Program", sut.Programs.ElementAt(0).Name); }
public void is_paused_cycles_correctly_if_pause_command_is_executed() { var scheduler = new TestScheduler(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction( new WaitActionBuilder() .WithDelayService(new DelayServiceBuilder().Build()) .WithDelay(TimeSpan.FromMinutes(1)) .Build()))) .WithScheduler(scheduler) .Build(); Assert.False(sut.IsPaused); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.False(sut.IsPaused); sut.PauseCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.True(sut.IsPaused); }
public void parse_error_message_returns_appropriate_message_if_the_document_could_not_be_parsed() { var document = @"# First Program ## First Exercise whatever!"; var scheduler = new TestScheduler(); var sut = new ExerciseProgramsViewModelBuilder() .WithCloudDocument(document) .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.NotNull(sut.ParseErrorMessage); Assert.Equal("Parsing failure: unexpected '#'; expected end of input (Line 3, Column 1); recently consumed: rogram\r\n\r\n", sut.ParseErrorMessage); }
public void is_started_cycles_correctly_if_start_command_is_executed() { var scheduler = new TestScheduler(); var sut = new ExerciseProgramViewModelBuilder() .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); var isStarted = sut .WhenAnyValue(x => x.IsStarted) .CreateCollection(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(3, isStarted.Count); Assert.False(isStarted[0]); Assert.True(isStarted[1]); Assert.False(isStarted[2]); }
public void skip_backwards_command_is_disabled_if_on_first_exercise() { var scheduler = new TestScheduler(); var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Execute(It.IsAny<ExecutionContext>())) .Return<ExecutionContext>( ec => { ec.IsPaused = true; return ec.WaitWhilePaused(); }); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction(action))) .WithScheduler(scheduler) .Build(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.False(sut.SkipBackwardsCommand.CanExecute.FirstAsync().Wait()); }
public void progress_is_updated_throughout_execution() { var scheduler = new TestScheduler(); var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Duration) .Return(TimeSpan.FromMinutes(1)); action .When(x => x.Execute(It.IsAny<ExecutionContext>())) .Return<ExecutionContext>( ec => { ec.AddProgress(TimeSpan.FromSeconds(15)); ec.AddProgress(TimeSpan.FromSeconds(30)); ec.IsPaused = true; return ec.WaitWhilePaused(); }); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction(action))) .WithScheduler(scheduler) .Build(); var progress = sut .WhenAnyValue(x => x.Progress) .CreateCollection(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(3, progress.Count); Assert.Equal(0, progress[0]); Assert.Equal(0.25, progress[1]); Assert.Equal(0.75, progress[2]); }
public void status_is_load_failed_if_the_document_fails_to_load_altogether() { var exerciseDocumentService = new ExerciseDocumentServiceMock(); var scheduler = new TestScheduler(); exerciseDocumentService .When(x => x.ExerciseDocument) .Return(Observable.Throw<string>(new InvalidOperationException())); var sut = new ExerciseProgramsViewModelBuilder() .WithExerciseDocumentService(exerciseDocumentService) .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.Equal(ExerciseProgramsViewModelStatus.LoadFailed, sut.Status); }
public void progress_is_calculated_based_on_duration_and_progress_time_span(int durationInMs, int progressInMs, double expectedProgress) { var scheduler = new TestScheduler(); var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Duration) .Return(TimeSpan.FromMilliseconds(durationInMs)); var model = new ExerciseBuilder() .WithBeforeExerciseAction(action) .Build(); var executionContext = new ExecutionContext(); var sut = new ExerciseViewModelBuilder() .WithSchedulerService(scheduler) .WithExecutionContext(executionContext) .WithModel(model) .Build(); executionContext.SetCurrentExercise(model); executionContext.AddProgress(TimeSpan.FromMilliseconds(progressInMs)); scheduler.AdvanceMinimal(); Assert.Equal(expectedProgress, sut.Progress); }
public void execution_context_is_cancelled_if_user_navigates_away() { var scheduler = new TestScheduler(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction( new WaitActionBuilder() .WithDelayService(new DelayServiceBuilder().Build()) .WithDelay(TimeSpan.FromMinutes(1)) .Build()))) .WithScheduler(scheduler) .Build(); sut .HostScreen .Router .NavigationStack .Add(sut); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.True(sut.IsStarted); sut .HostScreen .Router .NavigateBack .ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.False(sut.IsStarted); }
public void skip_forwards_command_skips_to_the_next_exercise() { var scheduler = new TestScheduler(); var action = new ActionMock(); action .When(x => x.Duration) .Return(TimeSpan.FromSeconds(10)); action .When(x => x.Execute(It.IsAny<ExecutionContext>())) .Return<ExecutionContext>( ec => { ec.IsPaused = true; return ec.WaitWhilePaused(); }); var exercise1 = new ExerciseBuilder() .WithName("Exercise 1") .WithBeforeExerciseAction(action) .Build(); var exercise2 = new ExerciseBuilder() .WithName("Exercise 2") .WithBeforeExerciseAction(action) .Build(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(exercise1) .WithExercise(exercise2)) .WithScheduler(scheduler) .Build(); var progress = sut .WhenAnyValue(x => x.ProgressTimeSpan) .CreateCollection(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); sut.SkipForwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(2, progress.Count); Assert.Equal(TimeSpan.Zero, progress[0]); Assert.Equal(TimeSpan.FromSeconds(10), progress[1]); }
public void skip_backwards_command_restarts_the_execution_context_from_the_start_of_the_previous_exercise_if_the_current_exercise_if_only_recently_started() { var scheduler = new TestScheduler(); var action = new ActionMock(); action .When(x => x.Duration) .Return(TimeSpan.FromSeconds(10)); action .When(x => x.Execute(It.IsAny<ExecutionContext>())) .Return<ExecutionContext>( ec => { ec.AddProgress(TimeSpan.FromSeconds(0.5)); ec.IsPaused = true; return ec.WaitWhilePaused(); }); var exercise1 = new ExerciseBuilder() .WithName("Exercise 1") .WithBeforeExerciseAction(action) .Build(); var exercise2 = new ExerciseBuilder() .WithName("Exercise 2") .WithBeforeExerciseAction(action) .Build(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(exercise1) .WithExercise(exercise2)) .WithScheduler(scheduler) .Build(); var progress = sut .WhenAnyValue(x => x.ProgressTimeSpan) .CreateCollection(); // start from the second exercise sut.StartCommand.ExecuteAsync(exercise1.Duration); scheduler.AdvanceMinimal(); sut.SkipBackwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(5, progress.Count); Assert.Equal(TimeSpan.Zero, progress[0]); Assert.Equal(TimeSpan.FromSeconds(10), progress[1]); Assert.Equal(TimeSpan.FromSeconds(10.5), progress[2]); Assert.Equal(TimeSpan.Zero, progress[3]); Assert.Equal(TimeSpan.FromSeconds(10), progress[4]); }
public void progress_time_span_reflects_any_progression_through_the_exercise() { var scheduler = new TestScheduler(); var model = new ExerciseBuilder() .Build(); var executionContext = new ExecutionContext(); var sut = new ExerciseViewModelBuilder() .WithSchedulerService(scheduler) .WithExecutionContext(executionContext) .WithModel(model) .Build(); executionContext.SetCurrentExercise(model); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.Zero, sut.ProgressTimeSpan); executionContext.AddProgress(TimeSpan.FromSeconds(3)); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan); executionContext.AddProgress(TimeSpan.FromSeconds(2)); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.FromSeconds(5), sut.ProgressTimeSpan); }
public void programs_is_null_if_both_cache_and_cloud_are_empty() { var scheduler = new TestScheduler(); var sut = new ExerciseProgramsViewModelBuilder() .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.Null(sut.Programs); }
public void programs_yields_any_successfully_parsed_programs() { var document = "# First Program"; var scheduler = new TestScheduler(); var sut = new ExerciseProgramsViewModelBuilder() .WithCloudDocument(document) .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.NotNull(sut.Programs); Assert.Equal(1, sut.Programs.Count); Assert.Equal("First Program", sut.Programs.ElementAt(0).Name); }
public void is_active_is_false_if_there_is_no_execution_context() { var scheduler = new TestScheduler(); var sut = new ExerciseViewModelBuilder() .WithSchedulerService(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.False(sut.IsActive); }
public void document_is_not_stored_in_cache_if_loaded_from_cache() { var document = "# First Program"; var scheduler = new TestScheduler(); var stateService = new StateServiceMock(); stateService .When(x => x.Get<string>(It.IsAny<string>())) .Return(Observable.Return(document)); stateService .When(x => x.Set<string>(It.IsAny<string>(), It.IsAny<string>())) .Return(Observable.Return(Unit.Default)); var sut = new ExerciseProgramsViewModelBuilder() .WithScheduler(scheduler) .WithStateService(stateService) .Build(); scheduler.AdvanceMinimal(); Assert.Equal(ExerciseProgramsViewModelStatus.LoadedFromCache, sut.Status); stateService .Verify(x => x.Set<string>("ExerciseProgramsDocument", document)) .WasNotCalled(); }
public void skip_backwards_command_is_enabled_if_sufficient_progress_has_been_made_through_first_exercise() { var scheduler = new TestScheduler(); var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Execute(It.IsAny<ExecutionContext>())) .Return<ExecutionContext>( ec => { ec.AddProgress(TimeSpan.FromSeconds(1)); ec.IsPaused = true; return ec.WaitWhilePaused(); }); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction(action))) .WithScheduler(scheduler) .Build(); // TODO: technically, I should just check CanExecute(null) at the end, but without this subscription the RxCommand does not update CanExecute correctly // try changing this once I'm using new RxCommand var canExecute = sut .SkipBackwardsCommand .CanExecute .CreateCollection(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(2, canExecute.Count); Assert.False(canExecute[0]); Assert.True(canExecute[1]); }
public void skip_backwards_command_restarts_the_execution_context_from_the_start_of_the_current_exercise_if_sufficient_progress_has_been_made() { var scheduler = new TestScheduler(); var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Execute(It.IsAny<ExecutionContext>())) .Return<ExecutionContext>( ec => { ec.AddProgress(TimeSpan.FromSeconds(4)); ec.IsPaused = true; return ec.WaitWhilePaused(); }); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction(action))) .WithScheduler(scheduler) .Build(); var progress = sut .WhenAnyValue(x => x.ProgressTimeSpan) .CreateCollection(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); sut.SkipBackwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(3, progress.Count); Assert.Equal(TimeSpan.Zero, progress[0]); Assert.Equal(TimeSpan.FromSeconds(4), progress[1]); Assert.Equal(TimeSpan.Zero, progress[2]); }
public void status_is_parse_failed_if_the_document_could_not_be_parsed() { var document = @"# First Program ## First Exercise whatever!"; var scheduler = new TestScheduler(); var sut = new ExerciseProgramsViewModelBuilder() .WithCloudDocument(document) .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.Equal(ExerciseProgramsViewModelStatus.ParseFailed, sut.Status); }
public void skip_forwards_command_is_disabled_if_on_last_exercise() { var scheduler = new TestScheduler(); var action = new ActionMock(); action .When(x => x.Duration) .Return(TimeSpan.FromSeconds(10)); action .When(x => x.Execute(It.IsAny<ExecutionContext>())) .Return<ExecutionContext>( ec => { ec.IsPaused = true; return ec.WaitWhilePaused(); }); var exercise1 = new ExerciseBuilder() .WithName("Exercise 1") .WithBeforeExerciseAction(action) .Build(); var exercise2 = new ExerciseBuilder() .WithName("Exercise 2") .WithBeforeExerciseAction(action) .Build(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(exercise1) .WithExercise(exercise2)) .WithScheduler(scheduler) .Build(); var canExecute = sut .SkipForwardsCommand .CanExecute .CreateCollection(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); sut.SkipForwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(5, canExecute.Count); Assert.False(canExecute[0]); Assert.True(canExecute[1]); Assert.False(canExecute[2]); Assert.True(canExecute[3]); Assert.False(canExecute[4]); }
public void programs_is_populated_from_cache_whilst_document_from_cloud_loads() { var cacheDocument = "# First Program"; var cloudDocument = @" # First Program # Second Program"; var scheduler = new TestScheduler(); var exerciseDocumentService = new ExerciseDocumentServiceMock(MockBehavior.Loose); exerciseDocumentService .When(x => x.ExerciseDocument) .Return( Observable .Return(cloudDocument) .Delay(TimeSpan.FromSeconds(3), scheduler)); var sut = new ExerciseProgramsViewModelBuilder() .WithExerciseDocumentService(exerciseDocumentService) .WithCachedDocument(cacheDocument) .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.NotNull(sut.Programs); Assert.Equal(1, sut.Programs.Count); scheduler.AdvanceBy(TimeSpan.FromSeconds(2)); Assert.NotNull(sut.Programs); Assert.Equal(1, sut.Programs.Count); scheduler.AdvanceBy(TimeSpan.FromSeconds(2)); Assert.NotNull(sut.Programs); Assert.Equal(2, sut.Programs.Count); }
public void current_exercise_reflects_that_in_the_execution_context() { var scheduler = new TestScheduler(); var action = new ActionMock(); action .When(x => x.Duration) .Return(TimeSpan.FromSeconds(10)); action .When(x => x.Execute(It.IsAny<ExecutionContext>())) .Return<ExecutionContext>( ec => { ec.IsPaused = true; return ec.WaitWhilePaused(); }); var exercise1 = new ExerciseBuilder() .WithName("Exercise 1") .WithBeforeExerciseAction(action) .Build(); var exercise2 = new ExerciseBuilder() .WithName("Exercise 2") .WithBeforeExerciseAction(action) .Build(); var exercise3 = new ExerciseBuilder() .WithName("Exercise 3") .WithBeforeExerciseAction(action) .Build(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(exercise1) .WithExercise(exercise2) .WithExercise(exercise3)) .WithScheduler(scheduler) .Build(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal("Exercise 1", sut.CurrentExercise?.Name); sut.SkipForwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal("Exercise 2", sut.CurrentExercise?.Name); sut.SkipForwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal("Exercise 3", sut.CurrentExercise?.Name); sut.SkipBackwardsCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal("Exercise 2", sut.CurrentExercise?.Name); }
public void programs_is_populated_from_cloud_if_cache_is_populated_and_cloud_is_populated() { var cacheDocument = "# First Program"; var cloudDocument = @" # First Program # Second Program"; var scheduler = new TestScheduler(); var sut = new ExerciseProgramsViewModelBuilder() .WithCloudDocument(cloudDocument) .WithCachedDocument(cacheDocument) .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.NotNull(sut.Programs); Assert.Equal(2, sut.Programs.Count); }
public void programs_is_populated_from_cloud_if_cache_errors_and_cloud_is_populated() { var document = "# First Program"; var stateService = new StateServiceMock(); var scheduler = new TestScheduler(); stateService .When(x => x.Get<string>(It.IsAny<string>())) .Return(Observable.Throw<string>(new InvalidOperationException())); stateService .When(x => x.Set<string>(It.IsAny<string>(), It.IsAny<string>())) .Return(Observable.Return(Unit.Default)); var sut = new ExerciseProgramsViewModelBuilder() .WithCloudDocument(document) .WithScheduler(scheduler) .WithStateService(stateService) .Build(); scheduler.AdvanceMinimal(); Assert.NotNull(sut.Programs); Assert.Equal(1, sut.Programs.Count); }
public void is_resume_visible_cycles_correctly_if_start_command_is_executed_and_execution_is_paused() { var scheduler = new TestScheduler(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction( new WaitActionBuilder() .WithDelayService(new DelayServiceBuilder().Build()) .WithDelay(TimeSpan.FromMinutes(1)) .Build()))) .WithScheduler(scheduler) .Build(); var isResumeVisible = sut .WhenAnyValue(x => x.IsResumeVisible) .CreateCollection(); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); sut.PauseCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.Equal(2, isResumeVisible.Count); Assert.False(isResumeVisible[0]); Assert.True(isResumeVisible[1]); }
public void is_start_visible_is_true_by_default() { var scheduler = new TestScheduler(); var sut = new ExerciseProgramViewModelBuilder() .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.True(sut.IsStartVisible); }
public void progress_time_span_is_reset_to_zero_if_the_execution_context_changes_to_null() { var scheduler = new TestScheduler(); var model = new ExerciseBuilder() .Build(); var executionContext = new ExecutionContext(); var executionContextSubject = new Subject<ExecutionContext>(); var sut = new ExerciseViewModelBuilder() .WithSchedulerService(scheduler) .WithExecutionContext(executionContextSubject) .WithModel(model) .Build(); executionContextSubject.OnNext(executionContext); executionContext.SetCurrentExercise(model); executionContext.AddProgress(TimeSpan.FromSeconds(3)); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan); executionContextSubject.OnNext(null); scheduler.AdvanceMinimal(); Assert.Equal(TimeSpan.Zero, sut.ProgressTimeSpan); }
public void is_paused_cycles_correctly_if_pause_command_is_executed() { var scheduler = new TestScheduler(); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction( new WaitActionBuilder() .WithDelayService(new DelayServiceBuilder().Build()) .WithDelay(TimeSpan.FromMinutes(1)) .Build()))) .WithScheduler(scheduler) .Build(); Assert.False(sut.IsPaused); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.False(sut.IsPaused); sut.PauseCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.True(sut.IsPaused); }
public void is_pause_visible_cycles_correctly_if_start_command_is_executed() { var scheduler = new TestScheduler(); var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Duration) .Return(TimeSpan.FromMinutes(1)); action .When(x => x.Execute(It.IsAny<ExecutionContext>())) .Return<ExecutionContext>( ec => Observable .Return(Unit.Default) .Do(_ => { }) .Delay(TimeSpan.FromMinutes(1), scheduler) .Do(_ => ec.AddProgress(TimeSpan.FromMinutes(1)))); var sut = new ExerciseProgramViewModelBuilder() .WithModel( new ExerciseProgramBuilder() .WithExercise( new ExerciseBuilder() .WithBeforeExerciseAction(action))) .WithScheduler(scheduler) .Build(); Assert.False(sut.IsPauseVisible); sut.StartCommand.ExecuteAsync(); scheduler.AdvanceMinimal(); Assert.True(sut.IsPauseVisible); scheduler.AdvanceBy(TimeSpan.FromMinutes(10)); Assert.False(sut.IsPauseVisible); }
public void status_is_loaded_from_cloud_if_document_is_successfully_loaded_from_cloud() { var document = "# First Program"; var scheduler = new TestScheduler(); var sut = new ExerciseProgramsViewModelBuilder() .WithCloudDocument(document) .WithScheduler(scheduler) .Build(); scheduler.AdvanceMinimal(); Assert.Equal(ExerciseProgramsViewModelStatus.LoadedFromService, sut.Status); }
public void is_active_is_false_if_this_exercise_is_not_the_current_exercise() { var scheduler = new TestScheduler(); var model1 = new ExerciseBuilder() .Build(); var model2 = new ExerciseBuilder() .Build(); var executionContext = new ExecutionContext(); var sut = new ExerciseViewModelBuilder() .WithSchedulerService(scheduler) .WithExecutionContext(executionContext) .WithModel(model1) .Build(); scheduler.AdvanceMinimal(); Assert.False(sut.IsActive); executionContext.SetCurrentExercise(model2); scheduler.AdvanceMinimal(); Assert.False(sut.IsActive); }